From 70d73e66782cc59cdc7a7603cac026c543f68131 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Thu, 27 Aug 2026 15:11:45 -0400 Subject: [PATCH 01/44] feat: implement aggregate-first lift/join pipeline --- Ix/Aiur/Protocol.lean | 14 + Ix/Aiur/Semantics/BytecodeFfi.lean | 15 + Ix/Cli/AggregateCmd.lean | 267 + Ix/Cli/CheckCmd.lean | 113 +- Ix/Cli/VerifyCmd.lean | 76 + Ix/MultiStark.lean | 104 +- Ix/MultiStark/Aggregate.lean | 578 + Ix/MultiStark/Host.lean | 89 + Main.lean | 2 + Tests/Main.lean | 1 + Tests/MultiStark.lean | 252 + crates/ffi/src/aiur/protocol.rs | 143 + crates/ixvm-codegen/src/aiur_multi_stark.rs | 10691 +++++++++++----- .../src/aiur_multi_stark_runner.rs | 293 +- 14 files changed, 9758 insertions(+), 2880 deletions(-) create mode 100644 Ix/Cli/AggregateCmd.lean create mode 100644 Ix/MultiStark/Aggregate.lean create mode 100644 Ix/MultiStark/Host.lean diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 57f954a8c..73c56f844 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -154,6 +154,20 @@ opaque proveMultiStark (system : @& AiurSystem) (proofBytes vkBytes claimBytes : @& ByteArray) (useBytecode : Bool := false) : Array G × Proof +/-- Prove one aggregate-first binary join over raw child proof/claim advice. +The compact preimage/tree blobs are produced by +`MultiStark.joinPreimagesBlob` and `MultiStark.joinTreesBlob`. 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) + (leftProofBytes rightProofBytes recursionVkBytes : @& ByteArray) + (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray) + (preimagesBlob treesBlob : @& 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 → diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index e699b165a..08e8b9878 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -174,6 +174,21 @@ opaque executeMultiStark (toplevel : @& Bytecode.Toplevel) (proofBytes vkBytes claimBytes : @& ByteArray) (useBytecode : Bool := false) : Except String (Array G × Array QueryCount) +/-- Native execution of the aggregate-first `join_two` entrypoint. The two +child proofs/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`; Rust expands them directly into IO channels 4 and +5. 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) + (leftProofBytes rightProofBytes recursionVkBytes : @& ByteArray) + (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray) + (preimagesBlob treesBlob : @& ByteArray) (useBytecode : Bool := false) : + Except String (Array G × Array QueryCount) + -- (EnvHandle opaque type + constructors live above `namespace -- Bytecode.Toplevel`; see `Aiur.EnvHandle`. The with-env FFI -- declarations below reference `EnvHandle` and `Bytecode.Toplevel` diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean new file mode 100644 index 000000000..06379a352 --- /dev/null +++ b/Ix/Cli/AggregateCmd.lean @@ -0,0 +1,267 @@ +/- + `ix aggregate --ixe E --ixes M ...` + + Bind persisted shard proof wrappers to every shard in a manifest, lift each + IxVM proof into the Multi-STARK recursion system, then execute/prove binary + joins in the manifest's bisection-tree order. The final persisted wrapper + carries the aggregate `CheckEnv` claim and recursive proof bytes. + + This first host driver is intentionally serial and cache-free. Its slot + model and content-addressed inputs make parallel scheduling and resumable + cache entries follow-up optimizations rather than protocol changes. +-/ +module +public import Cli +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 + statement : MultiStark.CheckEnvTrees + outerClaim : Array Aiur.G + proof : Aiur.Proof + /-- Preimages needed when this slot is decoded by its parent. A lift exposes + its inner claims plus `CheckEnv`; a join exposes only its output `CheckEnv`. -/ + openPreimages : Array ByteArray + +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.shardCheckEnvClaim 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 + +private def printPlan (plan : Array Ix.Cli.CheckCmd.AggregationTree.FoldOp) : IO Unit := do + let leaves := plan.countP fun op => match op with + | .leaf _ => true + | .join _ _ => false + IO.println s!"[aggregate] plan: {leaves} lifts + {plan.size - leaves} binary joins" + for (op, slot) in plan.mapIdx fun slot op => (op, slot) do + match op with + | .leaf shard => IO.println s!" slot {slot}: lift shard {shard}" + | .join left right => IO.println s!" slot {slot}: join slots {left}, {right}" + +def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do + let some ixePath := (p.flag? "ixe").map (·.as! String) | do + p.printError "error: aggregate requires --ixe " + return 1 + let some manifestPath := (p.flag? "ixes").map (·.as! String) | do + p.printError "error: aggregate requires --ixes " + return 1 + + 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 + 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 view.shards) then return 1 + if view.shards.size < 2 then + IO.eprintln "aggregate currently requires at least two shards (single-shard lift packaging is not yet exposed)" + return 1 + if view.shards.any (·.isEmpty) then + IO.eprintln "aggregate currently requires non-empty shards; regenerate or prune empty manifest leaves" + return 1 + + let plan := view.aggregationTree.foldPlan + printPlan plan + 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 item ← match prepareShard env blocks with + | .error e => IO.eprintln s!"prepare shard {shard}: {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}" + 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 lift. + 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 + if wrapper.claim != expected.claim then + IO.eprintln s!"proof {proofAddress} hit a claim-digest collision for shard {shard}" + return 1 + if proofsByShard.contains shard then + IO.eprintln s!"more than one proof supplied for shard {shard}" + 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 recursionCompiled ← match ← compileToplevel "MultiStark recursion" + MultiStark.multiStark with + | .error e => IO.eprintln e; return 1 + | .ok compiled => pure compiled + let verifyIdx := ixvmCompiled.getFuncIdx `verify_claim |>.get! + let liftIdx := recursionCompiled.getFuncIdx `verify_multi_stark_proof |>.get! + let joinIdx := recursionCompiled.getFuncIdx `join_two |>.get! + let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode + Aiur.defaultCommitmentParameters Aiur.defaultFriParameters + let recursionSystem := Aiur.AiurSystem.build recursionCompiled.bytecode + Aiur.defaultCommitmentParameters Aiur.defaultFriParameters + let ixvmVk := ixvmSystem.vkBytes + let recursionVk := recursionSystem.vkBytes + let allowed := MultiStark.allowedBlob ixvmVk verifyIdx recursionVk liftIdx joinIdx + + let mut slots : Array AggregateSlot := #[] + for (op, slotIdx) in plan.mapIdx fun slotIdx op => (op, slotIdx) do + match op with + | .leaf shard => + let some wrapper := proofsByShard.get? shard | do + IO.eprintln s!"internal: no proof for shard {shard}" + return 1 + let some item := prepared[shard]? | do + IO.eprintln s!"internal: no statement for shard {shard}" + return 1 + let claimBytes := Ix.Claim.ser item.claim + let verifyInput := IxVM.ClaimHarness.packedDigestKey + (Address.blake3 claimBytes) + let innerClaim := Aiur.buildClaim verifyIdx verifyInput #[] + let innerProof := Aiur.Proof.ofBytes wrapper.proof + match ixvmSystem.verify innerClaim innerProof with + | .error e => + IO.eprintln s!"shard {shard} proof fails native verification: {e}" + return 1 + | .ok () => pure () + let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] + let pubInput := MultiStark.verifierPubInput ixvmVk innerClaimsBytes + IO.println s!"[aggregate] lifting shard {shard} into slot {slotIdx}" + (← IO.getStdout).flush + let (outerClaim, proof) := recursionSystem.proveMultiStark liftIdx pubInput + wrapper.proof ixvmVk innerClaimsBytes + slots := slots.push { + statement := item.statement + outerClaim + proof + openPreimages := #[innerClaimsBytes, claimBytes] + } + | .join leftIdx rightIdx => + let some left := slots[leftIdx]? | do + IO.eprintln s!"invalid aggregate plan: missing left slot {leftIdx}" + return 1 + let some right := slots[rightIdx]? | do + IO.eprintln s!"invalid aggregate plan: missing right slot {rightIdx}" + return 1 + let output := left.statement.join right.statement + let outputClaimBytes := Ix.Claim.ser output.claim + let pubInput := MultiStark.joinPubInput allowed outputClaimBytes + let leftClaimsBytes := MultiStark.serializeClaims #[left.outerClaim] + let rightClaimsBytes := MultiStark.serializeClaims #[right.outerClaim] + let preimagesBlob := MultiStark.joinPreimagesBlob + (left.openPreimages ++ right.openPreimages) + let treesBlob := MultiStark.joinTreesBlob + (MultiStark.CheckEnvTrees.adviceTrees left.statement right.statement output) + IO.println s!"[aggregate] joining slots {leftIdx}, {rightIdx} into {slotIdx}" + (← IO.getStdout).flush + let result := recursionSystem.proveMultiStarkJoin joinIdx pubInput + left.proof.toBytes right.proof.toBytes recursionVk + leftClaimsBytes rightClaimsBytes outputClaimBytes allowed + preimagesBlob treesBlob + let (outerClaim, proof) ← match result with + | .error e => IO.eprintln s!"join slot {slotIdx}: {e}"; return 1 + | .ok result => pure result + slots := slots.push { + statement := output + outerClaim + proof + openPreimages := #[outputClaimBytes] + } + + let some root := slots.back? | do + IO.eprintln "aggregate plan produced no root slot" + return 1 + let some envTree := IxVM.ClaimHarness.envCanonicalTree env | do + IO.eprintln "cannot aggregate an empty environment" + return 1 + if root.statement.subjects.root != envTree.root then + IO.eprintln s!"aggregate root {root.statement.subjects.root} does not match 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 recursionSystem.verify root.outerClaim root.proof with + | .error e => IO.eprintln s!"aggregate root proof failed native verification: {e}"; return 1 + | .ok () => pure () + + let claim := root.statement.claim + let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) + let wrapper : Ixon.Proof := { claim, proof := root.proof.toBytes } + let proofAddress ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) + IO.println s!"[aggregate] root proof: {proofAddress}" + return 0 + +end Ix.Cli.AggregateCmd + +open Ix.Cli.AggregateCmd in +def aggregateCmd : Cli.Cmd := `[Cli| + aggregate VIA runAggregateCmd; + "Lift shard proofs and fold them into one recursive aggregate along a `.ixes` bisection tree" + + 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 lift/join slot plan without loading or proving shard proofs." + + ARGS: + ...proofs : String; "Persisted shard-proof wrapper addresses, in any order (exactly one per shard unless --plan-only)." +] + +end diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index c9a3caba1..72a007b11 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -428,34 +428,131 @@ 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)) + +end AggregationTree + +structure IxesManifestView where + shards : Array (Array Address) + 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, 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`). -/ diff --git a/Ix/Cli/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean index 8eb65094b..44185527d 100644 --- a/Ix/Cli/VerifyCmd.lean +++ b/Ix/Cli/VerifyCmd.lean @@ -18,6 +18,7 @@ public import Ix.Common public import Ix.IxVM public import Ix.IxVM.Toplevel public import Ix.IxVM.ClaimHarness +public import Ix.MultiStark public import Ix.Store public import Ix.Cli.CheckCmd @@ -79,6 +80,62 @@ def buildBackend : IO (Except String (Aiur.AiurSystem × Aiur.CompiledToplevel)) | .ok compiled => return .ok (Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters, compiled) +/-- Build the two deterministic systems whose identities are committed by an +aggregate root: the IxVM vk and the combined lift/join recursion vk. -/ +private def buildAggregateBackend : + IO (Except String (Aiur.AiurSystem × Aiur.Bytecode.FunIdx × ByteArray)) := 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 recursionCompiled ← match MultiStark.multiStark 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 liftIdx := recursionCompiled.getFuncIdx `verify_multi_stark_proof |>.get! + let joinIdx := recursionCompiled.getFuncIdx `join_two |>.get! + let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode + commitmentParameters friParameters + let recursionSystem := Aiur.AiurSystem.build recursionCompiled.bytecode + commitmentParameters friParameters + let recursionVk := recursionSystem.vkBytes + let allowed := MultiStark.allowedBlob ixvmSystem.vkBytes verifyIdx + recursionVk liftIdx joinIdx + return .ok (recursionSystem, joinIdx, allowed) + +private def verifyAggregateProof (recursionSystem : Aiur.AiurSystem) + (joinIdx : Aiur.Bytecode.FunIdx) (allowed : ByteArray) + (expectedEnv? : Option Ixon.Env) (proofAddr : Address) : IO UInt32 := do + let wrapper ← IO.ofExcept (Ixon.Proof.de (← StoreIO.toIO (Store.read proofAddr))) + let .checkEnv root assumptions := wrapper.claim | do + IO.eprintln s!"error: aggregate proof {proofAddr} does not bundle a CheckEnv claim" + return 1 + match expectedEnv? with + | some env => + let some expectedTree := IxVM.ClaimHarness.envCanonicalTree env | do + IO.eprintln "error: cannot verify an aggregate against an empty environment" + return 1 + if root != expectedTree.root then + IO.eprintln s!"error: aggregate subject root {root} does not match env root {expectedTree.root}" + return 1 + if assumptions.isSome then + IO.eprintln s!"error: aggregate retains assumptions {assumptions}" + return 1 + | none => pure () + let claimBytes := Ix.Claim.ser wrapper.claim + let pubInput := MultiStark.joinPubInput allowed claimBytes + let outerClaim := Aiur.buildClaim joinIdx pubInput #[] + match recursionSystem.verify outerClaim (Aiur.Proof.ofBytes wrapper.proof) with + | .error e => + IO.eprintln s!"error: aggregate verification failed: {e}" + return 1 + | .ok () => + IO.println s!"ok: aggregate proof {proofAddr} verifies {wrapper.claim}" + return 0 + /-- 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). @@ -148,6 +205,24 @@ def verifyShardComposition (ixePath manifestPath : String) (shardK? : Option Nat def runVerifyCmd (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 expectedEnv? ← match (p.flag? "ixe").map (·.as! String) with + | none => pure none + | some path => match Ixon.deEnvAnon (← IO.FS.readBinFile path) with + | .error e => IO.eprintln s!"deserialize {path} failed: {e}"; return 1 + | .ok env => pure (some env) + let (recursionSystem, joinIdx, allowed) ← match ← buildAggregateBackend 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 recursionSystem joinIdx allowed expectedEnv? 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 @@ -175,6 +250,7 @@ def verifyCmd : Cli.Cmd := `[Cli| "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)." "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 proof arguments as aggregate-first recursive roots. Rebuilds and pins both vks; with --ixe, also requires an unconditional claim for that exact env root." 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/MultiStark.lean b/Ix/MultiStark.lean index d093328b3..656c72b1f 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,11 @@ 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 second production entrypoint, `join_two`, verifies two lift/join proofs +under one pinned recursion vk and folds their `CheckEnv` statements by +canonical subject union and assumption discharge. Its 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 +96,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 +107,18 @@ 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) and `join_two`. 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]) /-! ## Lean-side input assembly @@ -138,14 +148,80 @@ 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]`). -/ +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 `join_two` wire contract 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 88-byte allowlist preimage for a recursive join: + +`blake3(ixvm vk) ‖ verify_claim index as u64-LE ‖ blake3(recursion vk) ‖ +lift index as u64-LE ‖ join index as u64-LE`. + +The verifying keys stay outside the public input. Their digests and all three +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 : 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⟩ + +/-- Public input for `join_two`: 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) + /-- 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..26bc140b9 --- /dev/null +++ b/Ix/MultiStark/Aggregate.lean @@ -0,0 +1,578 @@ +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`. + +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), + }, + } + } + + 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 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) + -> (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), + _ => + assert_eq!(child_idx, join_idx, + "join: child is neither lift nor 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). + let (aidx, alen) = io_get_info(3, [0]); + 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, astop) = @read_u64(as4); + assert_eq!(load(astop), ListNode.Nil, + "join: allowed blob must be exactly 88 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); + + -- 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); + let (right_root, right_asm) = join_decode_child(right_claims, + ixvm_vk_digest, allowed_digest, verify_claim_idx, lift_idx, 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); + () + } +⟧ + +end MultiStark + +end diff --git a/Ix/MultiStark/Host.lean b/Ix/MultiStark/Host.lean new file mode 100644 index 000000000..cdc0d86f1 --- /dev/null +++ b/Ix/MultiStark/Host.lean @@ -0,0 +1,89 @@ +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. These helpers give the +CLI one canonical implementation for constructing its claimed output and the +six tree preimages supplied to `join_two`. +-/ + +public section + +namespace MultiStark + +/-- A `CheckEnv` statement together with the canonical trees whose roots it +commits to. `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)) + +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 } + +/-- 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 leftAssumptions := left.assumptions.map (·.leaves) |>.getD #[] + let rightAssumptions := right.assumptions.map (·.leaves) |>.getD #[] + let remaining := (leftAssumptions ++ rightAssumptions).filter + (fun addr => !subjectSet.contains addr) + { subjects, assumptions := Ix.AssumptionTree.canonical remaining } + +/-- 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 + +end CheckEnvTrees + +end MultiStark + +end 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/Main.lean b/Tests/Main.lean index 6e9b547ce..b96e2735e 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -184,6 +184,7 @@ 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), ] /-- Ignored test runners - expensive, deferred IO actions run only when explicitly requested -/ diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index a1b09e149..81fa42536 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -5,6 +5,10 @@ public import Ix.Aiur.Meta public import Ix.Aiur.Protocol public import Ix.Aiur.Compiler public import Ix.MultiStark +public import Ix.Cli.CheckCmd +public import Ix.Claim +public import Ix.AssumptionTree +public import Ix.Merkle public import Blake3.Rust /-! @@ -226,6 +230,254 @@ 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 `join_two` 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 := ⟦ + pub fn fake_verify_claim(_digest: [G; 8]) { () } + pub fn fake_lift(_system_digest: [G; 8], _claims_digest: [G; 8]) { () } + pub fn fake_join(allowed_digest: [G; 8], _out_claim_digest: [G; 8]) { + assert_eq!(load(store(allowed_digest[0])), allowed_digest[0]); + () + } +⟧ + +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 minimalIxes (treeTail : Array UInt8) : ByteArray := + let shard := fun id => u32le4 id ++ Array.replicate 24 0 ++ #[0] ++ + u32le4 0 ++ u32le4 0 + ⟨#[0x49, 0x58, 0x45, 0x53, 0, 0, 0, 0] ++ Array.replicate 16 0 ++ + u32le4 2 ++ shard 0 ++ shard 1 ++ treeTail⟩ + +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 + let verifyIdx := childCompiled.getFuncIdx `fake_verify_claim |>.get! + let liftIdx := childCompiled.getFuncIdx `fake_lift |>.get! + let childJoinIdx := childCompiled.getFuncIdx `fake_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 recursionVk := childSystem.vkBytes + let allowed := MultiStark.allowedBlob fakeIxvmVk verifyIdx recursionVk + liftIdx childJoinIdx + let outputClaimBytes := Ix.Claim.ser outputStatement.claim + let pubInput := MultiStark.joinPubInput allowed outputClaimBytes + + 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 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 leftProof.toBytes) + |>.extend 0 oneKey (bytesAsGs rightProof.toBytes) + |>.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 honestInterp := compiled.bytecode.execute joinIdx pubInput io + let honest := compiled.bytecode.executeMultiStarkJoin joinIdx pubInput + leftProof.toBytes rightProof.toBytes recursionVk leftOuterBytes rightOuterBytes + outputClaimBytes allowed preimagesBlob treesBlob + 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 + leftProof.toBytes rightProof.toBytes recursionVk leftOuterBytes rightOuterBytes + outputClaimBytes allowed ⟨#[]⟩ treesBlob + + -- 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 joinChildIo := io + |>.extend 0 zeroKey (bytesAsGs joinChildProof.toBytes) + |>.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 wrongJoinIo := io + |>.extend 0 zeroKey (bytesAsGs wrongJoinProof.toBytes) + |>.extend 2 zeroKey (bytesAsGs wrongJoinOuterBytes) + let wrongTransitiveAllowed := + compiled.bytecode.execute joinIdx pubInput wrongJoinIo + + -- 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 := leftProof.toBytes.set! 0 + (UInt8.ofNat ((leftProof.toBytes.data[0]!.toNat + 1) % 256)) + let badProofIo := io.extend 0 zeroKey (bytesAsGs badLeftProofBytes) + let badProof := compiled.bytecode.execute joinIdx pubInput badProofIo + + 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 + + lspecIO (.ofList [("aggregate-first", [ + 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 "stand-in lift/join entrypoints survive compiler dedup separately" + (liftIdx != childJoinIdx), + 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 "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/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index acf20c60e..0bb9853a4 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -1008,6 +1008,95 @@ 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], +) -> Result { + use ixvm_codegen::aiur_multi_stark_runner::{ + JoinAdvice, decode_join_preimages, decode_join_trees, join_io_buffer, + }; + + let preimages = decode_join_preimages(preimages_blob)?; + let trees = decode_join_trees(trees_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, + })) +} + +/// `Bytecode.Toplevel.executeMultiStarkJoin`: execute `join_two` over raw +/// proof/claim/tree blobs. The native builder expands the compact keyed +/// preimage/tree framing directly into the circuit's six-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>, + fun_idx: LeanNat>, + pub_input: LeanArray>, + left_proof_bytes: LeanByteArray>, + right_proof_bytes: LeanByteArray>, + recursion_vk_bytes: LeanByteArray>, + left_claims_bytes: LeanByteArray>, + right_claims_bytes: LeanByteArray>, + output_claim_bytes: LeanByteArray>, + allowed_bytes: LeanByteArray>, + preimages_blob: LeanByteArray>, + trees_blob: LeanByteArray>, + use_bytecode: bool, +) -> LeanExcept { + 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(), + ) { + 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 /// and executor selection as in `rs_aiur_multi_stark_execute`; the @@ -1050,6 +1139,60 @@ extern "C" fn rs_aiur_multi_stark_prove( result.into() } +/// `AiurSystem.proveMultiStarkJoin`: prove one valid `join_two` 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>, + fun_idx: LeanNat>, + pub_input: LeanArray>, + left_proof_bytes: LeanByteArray>, + right_proof_bytes: LeanByteArray>, + recursion_vk_bytes: LeanByteArray>, + left_claims_bytes: LeanByteArray>, + right_claims_bytes: LeanByteArray>, + output_claim_bytes: LeanByteArray>, + allowed_bytes: LeanByteArray>, + preimages_blob: LeanByteArray>, + trees_blob: LeanByteArray>, + use_bytecode: bool, +) -> LeanExcept { + 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(), + ) { + 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)) +} + // ============================================================================= // Helpers // ============================================================================= diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 051a10e1a..dc4bc3ab5 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_227] = { let __args: [G; IN_227] = [__v_0]; 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 __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_227] = { let __args: [G; IN_227] = [__v_0]; 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 __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_227] = { let __args: [G; IN_227] = [__v_0]; 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 __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,64 @@ 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_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_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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4, __v_3]; 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_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 __ret: [G; OUT_88] = [__v_1, __v_5, __v_6]; + 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 +8598,44 @@ 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_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_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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_5, __v_4]; 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(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 __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_7, __v_9]; 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_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 __ret: [G; OUT_89] = [__v_13, __v_11]; + if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_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 +8643,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 +8655,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 +8667,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 +8679,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 +8701,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 +8712,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 +8723,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 +8734,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 +8931,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 +9018,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 +9044,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 +9060,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 +9071,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 +9082,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 +9093,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 +9292,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 +9312,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 +9375,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 +9394,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 +9412,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 +9434,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 +9445,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 +9456,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 +9467,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 +9478,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 +9489,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 +9517,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 +9545,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 +9556,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 +9567,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 +9578,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 +9589,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 +9600,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 +9628,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 +9639,36 @@ 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_87, __v_107]; 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_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 __ret: [G; OUT_97] = [__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[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 +9683,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 +9732,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 +9796,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 +9945,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 +9979,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 +10036,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 +10046,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 +10066,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 +10088,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 +10103,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 +10123,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 +10154,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 +10257,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 +10277,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 +10294,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 +10310,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 +10326,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 +10497,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 +10531,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 +10604,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 +10616,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 +10628,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 +10640,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 +10652,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 +10664,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 +10736,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 +10810,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 +10847,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 +10896,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 +10909,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 +10933,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 +10993,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 +11028,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 +11098,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 +11134,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 +11193,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 +11214,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 +11236,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 +11251,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 +11281,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 +11300,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 +11344,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_226] = { let __args: [G; IN_226] = [__v_0, __v_10]; 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_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 +11379,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 +11399,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 +11418,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 +11447,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 +11467,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 +11556,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 +11622,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 +11676,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 +11697,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 +11716,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 +11833,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 +11850,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 +11868,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 +11888,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 +11906,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 +11926,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 +11959,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 +11977,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 +11990,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 +12005,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 +12030,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 +12081,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 +12099,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 +12123,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 +12170,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 +12186,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 +12204,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_226] = { let __args: [G; IN_226] = [__v_0, __v_3]; 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_5: G = __r_arr[0]; let __v_6: G = (__v_1 - __v_4); let __v_7: G = (__v_5 + __v_6); @@ -11721,8 +12217,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 +12226,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 +12238,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 +12257,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 +12283,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 +12296,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 +12327,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 +12340,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 +12357,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 +12381,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 +12404,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 +12427,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 +12449,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 +12481,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 +12502,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_233] = { let __args: [G; IN_233] = [__v_2, __v_10]; 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_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 +12541,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_235] = { let __args: [G; IN_235] = [__v_6]; 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_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_230] = { let __args: [G; IN_230] = [__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_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 +12551,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 +12581,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_226] = { let __args: [G; IN_226] = [__v_8, __v_11]; 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_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_226] = { let __args: [G; IN_226] = [__v_8, __v_13]; 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_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 +12597,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 +12632,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_226] = { let __args: [G; IN_226] = [__v_6, __v_4]; 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_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_226] = { let __args: [G; IN_226] = [__v_9, __v_4]; 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_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_226] = { let __args: [G; IN_226] = [__v_10, __v_4]; 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_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 +12685,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_226] = { let __args: [G; IN_226] = [__v_6, __v_4]; 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_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_226] = { let __args: [G; IN_226] = [__v_9, __v_4]; 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_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_226] = { let __args: [G; IN_226] = [__v_10, __v_4]; 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_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_226] = { let __args: [G; IN_226] = [__v_16, __v_17]; 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_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 +12743,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_228] = { let __args: [G; IN_228] = [__v_8, __v_4]; 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 __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -12261,21 +12757,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_226] = { let __args: [G; IN_226] = [__v_7, __v_4]; 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_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_226] = { let __args: [G; IN_226] = [__v_11, __v_6]; 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_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_226] = { let __args: [G; IN_226] = [__v_12, __v_6]; 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_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 +12779,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 +12794,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 +12821,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_228] = { let __args: [G; IN_228] = [__v_1, __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 __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_238] = { let __args: [G; IN_238] = [__v_16]; 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_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_238] = { let __args: [G; IN_238] = [__v_4]; 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_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 +12848,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_233] = { let __args: [G; IN_233] = [__v_8, __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 __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 +12858,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 +12873,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 +12892,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_226] = { let __args: [G; IN_226] = [__v_0, __v_3]; 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_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 +12934,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 +12962,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 +12982,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_228] = { let __args: [G; IN_228] = [__v_2, __v_4]; 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 __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -12500,26 +12996,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_226] = { let __args: [G; IN_226] = [__v_0, __v_4]; 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_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 +13027,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 +13044,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 +13306,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 +13338,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 +13350,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 +13363,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 +13383,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 +13416,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_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_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 +13451,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_228] = { let __args: [G; IN_228] = [__v_11, __v_26]; 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 __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 +13559,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_230] = { let __args: [G; IN_230] = [__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_110: G = __r_arr[0]; let __v_111: G = G::from_u64(1); if (__v_110 != __v_111) { @@ -13229,17 +13725,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 +13762,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 +13799,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_228] = { let __args: [G; IN_228] = [__v_1, __v_28]; 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 __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_228] = { let __args: [G; IN_228] = [__v_1, __v_33]; 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 __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_228] = { let __args: [G; IN_228] = [__v_1, __v_38]; 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 __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 +13847,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_228] = { let __args: [G; IN_228] = [__v_23, __v_54]; 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 __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_229] = { let __args: [G; IN_229] = [__v_2]; 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 __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 +13862,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_230] = { let __args: [G; IN_230] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __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 +13874,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_238] = { let __args: [G; IN_238] = [__v_29]; 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_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 +13882,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_238] = { let __args: [G; IN_238] = [__v_34]; 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_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 +13896,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_238] = { let __args: [G; IN_238] = [__v_39]; 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_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 +13910,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 +13932,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 +13953,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 +13996,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 +14020,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 +14063,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_238] = { let __args: [G; IN_238] = [__v_6]; 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_31: G = __r_arr[0]; let __v_32: G = G::from_u64(1); let __v_33: G = G::from_u64(1); @@ -13577,7 +14073,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 +14083,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_232] = { let __args: [G; IN_232] = [__v_0, __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 = 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 +14155,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_232] = { let __args: [G; IN_232] = [__v_104, __v_108]; 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_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_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_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 +14179,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_230] = { let __args: [G; IN_230] = [__v_8]; 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_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 +14187,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_230] = { let __args: [G; IN_230] = [__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_122: G = __r_arr[0]; let __v_123: G = G::from_u64(1); if (__v_122 != __v_123) { @@ -13703,46 +14199,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 +14249,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 +14264,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 +14284,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 +14319,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 +14368,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], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, +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 +14400,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 +14438,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 +14459,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 +14477,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 +14489,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 +14504,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 +14572,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 +14610,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 +14679,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 +14766,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 +14812,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 +14852,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 +14868,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 +14899,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 +14910,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 +14933,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 +14947,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 +14963,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 +15026,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 +15064,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_232] = { let __args: [G; IN_232] = [__v_0, __v_12]; 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_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_232] = { let __args: [G; IN_232] = [__v_0, __v_5]; 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_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 +15152,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 +15183,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 +15203,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 +15220,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 +15236,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 +15255,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 +15310,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 +15332,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_232] = { let __args: [G; IN_232] = [__v_75, __v_81]; 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_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 +15363,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_232] = { let __args: [G; IN_232] = [__v_102, __v_108]; 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_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_232] = { let __args: [G; IN_232] = [__v_110, __v_114]; 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_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 +15400,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 +15592,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 +15628,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 +15867,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 +15908,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_230] = { let __args: [G; IN_230] = [__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_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_238] = { let __args: [G; IN_238] = [__v_21]; 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_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_238] = { let __args: [G; IN_238] = [__v_22]; 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]; 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_238] = { let __args: [G; IN_238] = [__v_18]; 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_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 +15971,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 +16003,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 +16030,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 +16043,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 +16065,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 +16090,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_236] = { let __args: [G; IN_236] = [__v_0, __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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -15602,8 +16098,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 +16107,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_228] = { let __args: [G; IN_228] = [__v_4, __v_18]; 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 __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_228] = { let __args: [G; IN_228] = [__v_5, __v_18]; 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 __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_228] = { let __args: [G; IN_228] = [__v_2, __v_18]; 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 __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_228] = { let __args: [G; IN_228] = [__v_3, __v_18]; 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 __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_228] = { let __args: [G; IN_228] = [__v_6, __v_18]; 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 __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_228] = { let __args: [G; IN_228] = [__v_7, __v_18]; 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 __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_228] = { let __args: [G; IN_228] = [__v_8, __v_16]; 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 __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 +16220,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 +16243,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 +16278,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 +16303,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 +16367,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 +16412,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 +16443,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 +16504,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 +16520,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 +16548,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 +16559,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_228] = { let __args: [G; IN_228] = [__v_35, __v_89]; 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 __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_228] = { let __args: [G; IN_228] = [__v_35, __v_94]; 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 __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_228] = { let __args: [G; IN_228] = [__v_36, __v_97]; 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 __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_228] = { let __args: [G; IN_228] = [__v_36, __v_102]; 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 __v_103: G = __r_arr[0]; let __v_104: G = __r_arr[1]; let __v_105: G = (__v_103 + __v_20); @@ -16088,23 +16584,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 +16609,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_228] = { let __args: [G; IN_228] = [__v_35, __v_91]; 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 __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_228] = { let __args: [G; IN_228] = [__v_35, __v_96]; 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 __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_228] = { let __args: [G; IN_228] = [__v_35, __v_101]; 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 __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_228] = { let __args: [G; IN_228] = [__v_35, __v_106]; 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 __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 +16661,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 +16673,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 +16693,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], - record: &mut QueryRecord, +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 +16733,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 +16790,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_228] = { let __args: [G; IN_228] = [__v_9, __v_82]; 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 __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_228] = { let __args: [G; IN_228] = [__v_8, __v_85]; 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 __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_228] = { let __args: [G; IN_228] = [__v_9, __v_94]; 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 __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_228] = { let __args: [G; IN_228] = [__v_8, __v_97]; 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 __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_230] = { let __args: [G; IN_230] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(0); let __v_85: G = G::from_u64(1); @@ -16340,11 +16836,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 +16850,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 +16895,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 +16925,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 +16946,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 +16962,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 +17114,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 +17127,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_226] = { let __args: [G; IN_226] = [__v_1, __v_3]; 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_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_226] = { let __args: [G; IN_226] = [__v_4, __v_5]; 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_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_226] = { let __args: [G; IN_226] = [__v_4, __v_7]; 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_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 +17156,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 +17198,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_226] = { let __args: [G; IN_226] = [__v_2, __v_9]; 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_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_228] = { let __args: [G; IN_228] = [__v_3, __v_9]; 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 __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_226] = { let __args: [G; IN_226] = [__v_4, __v_9]; 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_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_226] = { let __args: [G; IN_226] = [__v_32, __v_33]; 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_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_226] = { let __args: [G; IN_226] = [__v_32, __v_35]; 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 __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_226] = { let __args: [G; IN_226] = [__v_5, __v_9]; 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 = 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_226] = { let __args: [G; IN_226] = [__v_37, __v_38]; 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_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_226] = { let __args: [G; IN_226] = [__v_37, __v_40]; 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_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_228] = { let __args: [G; IN_228] = [__v_1, __v_9]; 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 __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 +17253,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_226] = { let __args: [G; IN_226] = [__v_7, __v_43]; 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_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_226] = { let __args: [G; IN_226] = [__v_44, __v_45]; 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 = 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_226] = { let __args: [G; IN_226] = [__v_44, __v_47]; 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_48: G = __r_arr[0]; break '__mc_0 [__v_46, __v_48]; }, @@ -16779,14 +17275,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 +17420,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 +17441,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 +17498,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_228] = { let __args: [G; IN_228] = [__v_41, __v_230]; 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 __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_228] = { let __args: [G; IN_228] = [__v_39, __v_233]; 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 __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_228] = { let __args: [G; IN_228] = [__v_41, __v_242]; 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 __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_228] = { let __args: [G; IN_228] = [__v_39, __v_245]; 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 __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_230] = { let __args: [G; IN_230] = [__v_25]; 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_231: G = __r_arr[0]; let __v_232: G = G::from_u64(0); let __v_233: G = G::from_u64(1); @@ -17046,7 +17542,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 +17554,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_226] = { let __args: [G; IN_226] = [__v_8, __v_9]; 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_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_226] = { let __args: [G; IN_226] = [__v_232, __v_233]; 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_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 +17583,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_230] = { let __args: [G; IN_230] = [__v_235]; 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_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 +17602,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 +17617,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 +17645,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 +17672,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 +17685,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 +17696,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 +17719,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 +17754,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 +17768,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 +17821,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 +17843,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 +17898,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 +17920,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_232] = { let __args: [G; IN_232] = [__v_106, __v_112]; 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_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 +17951,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_232] = { let __args: [G; IN_232] = [__v_133, __v_139]; 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_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_232] = { let __args: [G; IN_232] = [__v_141, __v_145]; 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_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 +17988,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 +18182,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_237] = { let __args: [G; IN_237] = [__v_37]; 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_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_238] = { let __args: [G; IN_238] = [__v_18]; 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_365: G = __r_arr[0]; let __v_366: G = G::from_u64(1); let __v_367: G = G::from_u64(1); @@ -17706,7 +18202,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 +18212,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_232] = { let __args: [G; IN_232] = [__v_188, __v_372]; 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_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 +18284,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_232] = { let __args: [G; IN_232] = [__v_438, __v_442]; 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_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_238] = { let __args: [G; IN_238] = [__v_12]; 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_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_237] = { let __args: [G; IN_237] = [__v_8]; 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_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 +18316,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_237] = { let __args: [G; IN_237] = [__v_37]; 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_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_230] = { let __args: [G; IN_230] = [__v_16]; 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_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 +18326,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_235] = { let __args: [G; IN_235] = [__v_19]; 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_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 +18334,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_230] = { let __args: [G; IN_230] = [__v_20]; 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_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 +18342,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_230] = { let __args: [G; IN_230] = [__v_21]; 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_468: G = __r_arr[0]; let __v_469: G = G::from_u64(1); if (__v_468 != __v_469) { @@ -17858,10 +18354,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 +18372,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 +18390,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 +18402,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 +18415,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 +18441,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 +18454,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 +18483,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 +18505,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 +18518,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 +18547,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 +18587,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 +18653,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 +18670,4254 @@ 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], +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_232] = { let __args: [G; IN_232] = [__v_3, __v_5]; 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_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_227] = { let __args: [G; IN_227] = [__v_40]; 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 __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 = 1; +const IN_214: usize = 1; +const OUT_214: usize = 3; +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 __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_214] = [__v_3, __v_4, __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); + }, + 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_214] = [__v_5, __v_3, __v_4]; + 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); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_215: usize = 1; +const IN_215: usize = 1; +const OUT_215: usize = 3; +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 __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_214] = { let __args: [G; IN_214] = [__v_4]; 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_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_215] = [__v_3, __v_5, __v_6]; + 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 = 8; +const IN_216: usize = 8; +const OUT_216: usize = 1; +fn aiur_fn_216( + inp: [G; IN_216], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_216], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + 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_216] = [__v_12]; + 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); + }) +} + +const INPUT_SIZE_217: usize = 2; +const IN_217: usize = 2; +const OUT_217: usize = 1; +fn aiur_fn_217( + inp: [G; IN_217], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_217], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __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_217] = [__v_30]; + 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); + }) +} + +const INPUT_SIZE_218: usize = 2; +const IN_218: usize = 2; +const OUT_218: usize = 8; +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 __v_1: G = inp[1]; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __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_217] = { let __args: [G; IN_217] = [__v_0, __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 = G::from_u64(2); + let __v_7: G = (__v_1 + __v_6); + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_7]; 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_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_217] = { let __args: [G; IN_217] = [__v_0, __v_10]; 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_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_217] = { let __args: [G; IN_217] = [__v_0, __v_13]; 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_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_217] = { let __args: [G; IN_217] = [__v_0, __v_16]; 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_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_217] = { let __args: [G; IN_217] = [__v_0, __v_19]; 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_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_217] = { let __args: [G; IN_217] = [__v_0, __v_22]; 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_23: G = __r_arr[0]; + let __ret: [G; OUT_218] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23]; + 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 = 16; +const IN_219: usize = 16; +const OUT_219: usize = 0; +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 = 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_219] = []; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_220: usize = 1; +const IN_220: usize = 1; +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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_220] = [__v_2]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_221: usize = 13; +const IN_221: usize = 13; +const OUT_221: usize = 1; +fn aiur_fn_221( + inp: [G; IN_221], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_221], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + 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_230] = { let __args: [G; IN_230] = [__v_26]; 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_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_232] = { let __args: [G; IN_232] = [__v_141, __v_147]; 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_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_232] = { let __args: [G; IN_232] = [__v_168, __v_174]; 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_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_232] = { let __args: [G; IN_232] = [__v_176, __v_180]; 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_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_237] = { let __args: [G; IN_237] = [__v_72]; 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_399: G = __r_arr[0]; + match __v_34.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_34]; 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_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_232] = { let __args: [G; IN_232] = [__v_223, __v_407]; 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_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_232] = { let __args: [G; IN_232] = [__v_473, __v_477]; 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_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_238] = { let __args: [G; IN_238] = [__v_58]; 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_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_238] = { let __args: [G; IN_238] = [__v_60]; 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_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_238] = { let __args: [G; IN_238] = [__v_53]; 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_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_238] = { let __args: [G; IN_238] = [__v_18]; 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_500: G = __r_arr[0]; + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_8]; 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_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_237] = { let __args: [G; IN_237] = [__v_72]; 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_505: G = __r_arr[0]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_26]; 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_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_235] = { let __args: [G; IN_235] = [__v_36]; 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_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_230] = { let __args: [G; IN_230] = [__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_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_230] = { let __args: [G; IN_230] = [__v_42]; 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_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_221] = [__v_69]; + 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 = 2; +const IN_222: usize = 2; +const OUT_222: usize = 3; +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 = G::from_u64(10); + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0, __v_2]; 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_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_216] = { let __args: [G; IN_216] = [__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[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_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_220] = { let __args: [G; IN_220] = [__v_14]; 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_16: G = __r_arr[0]; + let __v_17: G = G::from_u64(2); + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_16, __v_17]; 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_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_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_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_217] = { let __args: [G; IN_217] = [__v_16, __v_33]; 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_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_217] = { let __args: [G; IN_217] = [__v_16, __v_36]; 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_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_216] = { let __args: [G; IN_216] = [__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[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_38: G = __r_arr[0]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_38]; 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_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __v_41: G = __r_arr[2]; + let __ret: [G; OUT_222] = [__v_39, __v_40, __v_41]; + 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 = 20; +const IN_223: usize = 20; +const OUT_223: usize = 3; +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 __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 __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0]; 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(1); + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_20, __v_21]; 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_22: G = __r_arr[0]; + 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_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(18); + if (__v_23 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("join: recursive child claim must contain 16 public inputs".to_string()) }); + } + let __v_25: G = G::from_u64(0); + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_20, __v_25]; 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_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(0); + if (__v_26 != __v_27) { + return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("join: recursive child has the wrong claim channel".to_string()) }); + } + let __v_28: G = (__v_22 - __v_18); + let __v_29: G = G::from_bool((__v_28 == G::ZERO)); + match __v_29.as_canonical_u64() { + 1u64 => { + let __v_30: G = G::from_u64(2); + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_20, __v_30]; 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_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 __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_20, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __v_41: G = __r_arr[2]; + let __ret: [G; OUT_223] = [__v_39, __v_40, __v_41]; + 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); + }, + _ => { + let __v_30: G = G::from_u64(2); + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_20, __v_30]; 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_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 __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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[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_39: G = G::from_u64(10); + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_20, __v_39]; 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_40: G = __r_arr[0]; + let __v_41: G = __r_arr[1]; + let __v_42: G = __r_arr[2]; + let __v_43: G = __r_arr[3]; + let __v_44: G = __r_arr[4]; + let __v_45: G = __r_arr[5]; + let __v_46: G = __r_arr[6]; + let __v_47: G = __r_arr[7]; + if (__v_22 != __v_19) { + return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("join: child is neither lift nor join".to_string()) }); + } + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_48: G = __r_arr[0]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_48]; 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_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __v_51: G = __r_arr[2]; + let __ret: [G; OUT_223] = [__v_49, __v_50, __v_51]; + 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); + }, + } + }) +} + +const INPUT_SIZE_224: usize = 16; +const IN_224: usize = 16; +const OUT_224: usize = 0; +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 = 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_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_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 __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_165: G = __r_arr[0]; + let __v_166: G = __r_arr[1]; + let __v_167: G = __r_arr[2]; + let __v_168: G = __r_arr[3]; + let __v_169: G = __r_arr[4]; + let __v_170: G = __r_arr[5]; + let __v_171: G = __r_arr[6]; + let __v_172: G = __r_arr[7]; + let __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_173: 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_174: 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_175: G = __r_arr[0]; + let __v_176: G = G::from_u64(1); + let __v_177: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_177]; let __info = io_buffer.get_info(__v_176, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_178: G = __io_pair.0; + let __v_179: G = __io_pair.1; + let __v_180: G = G::from_u64(1); + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_180, __v_178, __v_179]; 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_181: G = __r_arr[0]; + 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(127); + let __v_199: G = G::from_u64(82); + let __v_200: G = G::from_u64(14); + let __v_201: G = G::from_u64(81); + let __v_202: G = G::from_u64(140); + let __v_203: G = G::from_u64(104); + let __v_204: G = G::from_u64(5); + let __v_205: G = G::from_u64(155); + let __v_206: G = G::from_u64(171); + let __v_207: G = G::from_u64(217); + let __v_208: G = G::from_u64(131); + let __v_209: G = G::from_u64(31); + let __v_210: G = G::from_u64(25); + let __v_211: G = G::from_u64(205); + let __v_212: G = G::from_u64(224); + let __v_213: G = G::from_u64(91); + let __v_214: G = G::from_u64(1); + let __v_215: G = G::from_u64(1); + let __v_216: G = { let __values: [G; 3] = [__v_214, __v_215, __v_215]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0); + let __v_218: G = G::from_u64(0); + let __v_219: G = G::from_u64(0); + let __v_220: G = G::from_u64(0); + let __v_221: G = G::from_u64(0); + let __v_222: G = G::from_u64(0); + let __v_223: G = G::from_u64(0); + let __v_224: G = G::from_u64(0); + let __v_225: G = G::from_u64(0); + let __v_226: G = G::from_u64(0); + let __v_227: G = { let __values: [G; 8] = [__v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226]; 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_228: G = { let __values: [G; 32] = [__v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1); + let __v_230: G = G::from_u64(1); + let __v_231: G = { let __values: [G; 34] = [__v_229, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230]; 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_181, __v_216, __v_217, __v_218, __v_227, __v_228, __v_231]; 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_232: G = __r_arr[0]; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_232]; 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_233: G = __r_arr[0]; + let __v_234: G = __r_arr[1]; + let __v_235: G = __r_arr[2]; + let __v_236: G = __r_arr[3]; + let __v_237: G = __r_arr[4]; + let __v_238: G = __r_arr[5]; + let __v_239: G = __r_arr[6]; + let __v_240: G = __r_arr[7]; + let __v_241: G = __r_arr[8]; + let __v_242: G = __r_arr[9]; + let __v_243: G = __r_arr[10]; + let __v_244: G = __r_arr[11]; + let __v_245: G = __r_arr[12]; + let __v_246: G = __r_arr[13]; + let __v_247: G = __r_arr[14]; + let __v_248: G = __r_arr[15]; + let __v_249: G = __r_arr[16]; + let __v_250: G = __r_arr[17]; + let __v_251: G = __r_arr[18]; + let __v_252: G = __r_arr[19]; + let __v_253: G = __r_arr[20]; + let __v_254: G = __r_arr[21]; + let __v_255: G = __r_arr[22]; + let __v_256: G = __r_arr[23]; + let __v_257: G = __r_arr[24]; + let __v_258: G = __r_arr[25]; + let __v_259: G = __r_arr[26]; + let __v_260: G = __r_arr[27]; + let __v_261: G = __r_arr[28]; + let __v_262: G = __r_arr[29]; + let __v_263: G = __r_arr[30]; + let __v_264: G = __r_arr[31]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_181]; 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_265: G = __r_arr[0]; + let __v_266: G = __r_arr[1]; + let __v_267: G = __r_arr[2]; + let __v_268: G = __r_arr[3]; + let __v_269: G = __r_arr[4]; + let __v_270: G = __r_arr[5]; + let __v_271: G = __r_arr[6]; + let __v_272: G = __r_arr[7]; + let __v_273: G = __r_arr[8]; + let __v_274: G = __r_arr[9]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_274]; 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_275: G = __r_arr[0]; + let __v_276: G = __r_arr[1]; + let __v_277: G = __r_arr[2]; + let __v_278: G = __r_arr[3]; + let __v_279: G = __r_arr[4]; + let __v_280: G = __r_arr[5]; + let __v_281: G = __r_arr[6]; + let __v_282: G = __r_arr[7]; + let __v_283: G = __r_arr[8]; + let __v_284: G = __r_arr[9]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_284]; 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_285: G = __r_arr[0]; + let __v_286: G = __r_arr[1]; + let __v_287: G = __r_arr[2]; + let __v_288: G = __r_arr[3]; + let __v_289: G = __r_arr[4]; + let __v_290: G = __r_arr[5]; + let __v_291: G = __r_arr[6]; + let __v_292: G = __r_arr[7]; + let __v_293: G = __r_arr[8]; + let __v_294: G = __r_arr[9]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_294]; 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_295: G = __r_arr[0]; + let __v_296: G = __r_arr[1]; + let __v_297: G = __r_arr[2]; + let __v_298: G = __r_arr[3]; + let __v_299: G = __r_arr[4]; + let __v_300: G = __r_arr[5]; + let __v_301: G = __r_arr[6]; + let __v_302: G = __r_arr[7]; + let __v_303: G = __r_arr[8]; + let __v_304: G = __r_arr[9]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_304]; 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_305: G = __r_arr[0]; + let __v_306: G = __r_arr[1]; + let __v_307: G = __r_arr[2]; + let __v_308: G = __r_arr[3]; + let __v_309: G = __r_arr[4]; + let __v_310: G = __r_arr[5]; + let __v_311: G = __r_arr[6]; + let __v_312: G = __r_arr[7]; + let __v_313: G = __r_arr[8]; + let __v_314: G = __r_arr[9]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_314]; 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_315: G = __r_arr[0]; + let __v_316: G = __r_arr[1]; + let __v_317: G = __r_arr[2]; + let __v_318: G = __r_arr[3]; + let __v_319: G = __r_arr[4]; + let __v_320: G = __r_arr[5]; + let __v_321: G = __r_arr[6]; + let __v_322: G = __r_arr[7]; + let __v_323: G = __r_arr[8]; + let __v_324: G = __r_arr[9]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_324]; 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_325: G = __r_arr[0]; + let __v_326: G = __r_arr[1]; + let __v_327: G = __r_arr[2]; + let __v_328: G = __r_arr[3]; + let __v_329: G = __r_arr[4]; + let __v_330: G = __r_arr[5]; + let __v_331: G = __r_arr[6]; + let __v_332: G = __r_arr[7]; + let __v_333: G = __r_arr[8]; + let __v_334: G = __r_arr[9]; + let __v_335: G = G::from_u64(0); + let __v_336: G = G::from_u64(0); + let __v_337: G = G::from_u64(0); + let __v_338: G = G::from_u64(0); + let __v_339: G = G::from_u64(0); + let __v_340: G = G::from_u64(0); + let __v_341: G = G::from_u64(0); + let __v_342: G = G::from_u64(1); + let __v_343: G = G::from_u64(1); + let __v_344: G = { let __values: [G; 10] = [__v_342, __v_343, __v_343, __v_343, __v_343, __v_343, __v_343, __v_343, __v_343, __v_343]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_345: G = { let __values: [G; 10] = [__v_341, __v_326, __v_327, __v_328, __v_329, __v_330, __v_331, __v_332, __v_333, __v_344]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_346: G = { let __values: [G; 10] = [__v_340, __v_316, __v_317, __v_318, __v_319, __v_320, __v_321, __v_322, __v_323, __v_345]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_347: G = { let __values: [G; 10] = [__v_339, __v_306, __v_307, __v_308, __v_309, __v_310, __v_311, __v_312, __v_313, __v_346]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_348: G = { let __values: [G; 10] = [__v_338, __v_296, __v_297, __v_298, __v_299, __v_300, __v_301, __v_302, __v_303, __v_347]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_349: G = { let __values: [G; 10] = [__v_337, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_348]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_350: G = { let __values: [G; 10] = [__v_336, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_349]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_351: G = { let __values: [G; 10] = [__v_335, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_350]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_334]; 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_352: G = __r_arr[0]; + let __v_353: G = __r_arr[1]; + let __v_354: G = __r_arr[2]; + let __v_355: G = __r_arr[3]; + let __v_356: G = __r_arr[4]; + let __v_357: G = __r_arr[5]; + let __v_358: G = __r_arr[6]; + let __v_359: G = __r_arr[7]; + let __v_360: G = __r_arr[8]; + let __v_361: G = __r_arr[9]; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_361, __v_352]; 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_362: G = __r_arr[0]; + let __v_363: G = __r_arr[1]; + let __v_364: G = __r_arr[2]; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_364]; 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_365: G = __r_arr[0]; + let __v_366: G = __r_arr[1]; + let __v_367: G = __r_arr[2]; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_367, __v_352]; 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_368: G = __r_arr[0]; + let __v_369: G = __r_arr[1]; + let __v_370: G = G::from_u64(0); + let __v_371: G = { let __values: [G; 10] = [__v_370, __v_353, __v_354, __v_355, __v_356, __v_357, __v_358, __v_359, __v_360, __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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_351, __v_371]; 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_372: G = __r_arr[0]; + let __v_373: G = G::from_u64(0); + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_265, __v_275, __v_285, __v_295, __v_305, __v_315, __v_325, __v_372, __v_362, __v_365, __v_366, __v_368, __v_373]; 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_374: G = __r_arr[0]; + let __v_375: G = G::from_u64(1); + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_265, __v_275, __v_285, __v_295, __v_305, __v_315, __v_325, __v_372, __v_362, __v_365, __v_366, __v_368, __v_375]; 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_376: G = __r_arr[0]; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_374, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_173, __v_174, __v_175]; 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_377: G = __r_arr[0]; + let __v_378: G = __r_arr[1]; + let __v_379: G = __r_arr[2]; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_376, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_173, __v_174, __v_175]; 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_380: G = __r_arr[0]; + let __v_381: G = __r_arr[1]; + let __v_382: G = __r_arr[2]; + let __v_383: G = G::from_u64(2); + let __v_384: G = G::from_u64(2); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_384]; let __info = io_buffer.get_info(__v_383, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_385: G = __io_pair.0; + let __v_386: G = __io_pair.1; + let __v_387: G = G::from_u64(2); + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_387, __v_385, __v_386]; 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_388: G = __r_arr[0]; + let __v_389: G = G::from_u64(103); + let __v_390: G = G::from_u64(230); + let __v_391: G = G::from_u64(9); + let __v_392: G = G::from_u64(106); + let __v_393: G = G::from_u64(133); + let __v_394: G = G::from_u64(174); + let __v_395: G = G::from_u64(103); + let __v_396: G = G::from_u64(187); + let __v_397: G = G::from_u64(114); + let __v_398: G = G::from_u64(243); + let __v_399: G = G::from_u64(110); + let __v_400: G = G::from_u64(60); + let __v_401: G = G::from_u64(58); + let __v_402: G = G::from_u64(245); + let __v_403: G = G::from_u64(79); + let __v_404: G = G::from_u64(165); + let __v_405: G = G::from_u64(127); + let __v_406: G = G::from_u64(82); + let __v_407: G = G::from_u64(14); + let __v_408: G = G::from_u64(81); + let __v_409: G = G::from_u64(140); + let __v_410: G = G::from_u64(104); + let __v_411: G = G::from_u64(5); + let __v_412: G = G::from_u64(155); + let __v_413: G = G::from_u64(171); + let __v_414: G = G::from_u64(217); + let __v_415: G = G::from_u64(131); + let __v_416: G = G::from_u64(31); + let __v_417: G = G::from_u64(25); + let __v_418: G = G::from_u64(205); + let __v_419: G = G::from_u64(224); + let __v_420: G = G::from_u64(91); + let __v_421: G = G::from_u64(1); + let __v_422: G = G::from_u64(1); + let __v_423: G = { let __values: [G; 3] = [__v_421, __v_422, __v_422]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_424: G = G::from_u64(0); + let __v_425: G = G::from_u64(0); + let __v_426: G = G::from_u64(0); + let __v_427: G = G::from_u64(0); + let __v_428: G = G::from_u64(0); + let __v_429: G = G::from_u64(0); + let __v_430: G = G::from_u64(0); + let __v_431: G = G::from_u64(0); + let __v_432: G = G::from_u64(0); + let __v_433: G = G::from_u64(0); + let __v_434: G = { let __values: [G; 8] = [__v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433]; 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_435: G = { let __values: [G; 32] = [__v_389, __v_390, __v_391, __v_392, __v_393, __v_394, __v_395, __v_396, __v_397, __v_398, __v_399, __v_400, __v_401, __v_402, __v_403, __v_404, __v_405, __v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1); + let __v_437: G = G::from_u64(1); + let __v_438: G = { let __values: [G; 34] = [__v_436, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437]; 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_388, __v_423, __v_424, __v_425, __v_434, __v_435, __v_438]; 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_439: G = __r_arr[0]; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_439]; 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_440: G = __r_arr[0]; + let __v_441: G = __r_arr[1]; + let __v_442: G = __r_arr[2]; + let __v_443: G = __r_arr[3]; + let __v_444: G = __r_arr[4]; + let __v_445: G = __r_arr[5]; + let __v_446: G = __r_arr[6]; + let __v_447: G = __r_arr[7]; + let __v_448: G = __r_arr[8]; + let __v_449: G = __r_arr[9]; + let __v_450: G = __r_arr[10]; + let __v_451: G = __r_arr[11]; + let __v_452: G = __r_arr[12]; + let __v_453: G = __r_arr[13]; + let __v_454: G = __r_arr[14]; + let __v_455: G = __r_arr[15]; + let __v_456: G = __r_arr[16]; + let __v_457: G = __r_arr[17]; + let __v_458: G = __r_arr[18]; + let __v_459: G = __r_arr[19]; + let __v_460: G = __r_arr[20]; + let __v_461: G = __r_arr[21]; + let __v_462: G = __r_arr[22]; + let __v_463: G = __r_arr[23]; + let __v_464: G = __r_arr[24]; + let __v_465: G = __r_arr[25]; + let __v_466: G = __r_arr[26]; + let __v_467: G = __r_arr[27]; + let __v_468: G = __r_arr[28]; + let __v_469: G = __r_arr[29]; + let __v_470: G = __r_arr[30]; + let __v_471: G = __r_arr[31]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_388]; 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_472: G = __r_arr[0]; + let __v_473: G = __r_arr[1]; + let __v_474: G = __r_arr[2]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_377]; 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_475: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_380]; 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_476: G = __r_arr[0]; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_378, __v_379]; 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_477: G = __r_arr[0]; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_381, __v_382]; 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_478: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_472]; 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_479: G = __r_arr[0]; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_473, __v_474]; 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_480: G = __r_arr[0]; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_475, __v_476, __v_479]; 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_477, __v_478, __v_479, __v_480]; 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_481: G = G::from_u64(256); + let __v_482: G = (__v_481 * __v_74); + let __v_483: G = G::from_u64(65536); + let __v_484: G = (__v_483 * __v_75); + let __v_485: G = G::from_u64(16777216); + let __v_486: G = (__v_485 * __v_76); + let __v_487: G = (__v_484 + __v_486); + let __v_488: G = (__v_482 + __v_487); + let __v_489: G = (__v_73 + __v_488); + let __v_490: G = G::from_u64(256); + let __v_491: G = (__v_490 * __v_78); + let __v_492: G = G::from_u64(65536); + let __v_493: G = (__v_492 * __v_79); + let __v_494: G = G::from_u64(16777216); + let __v_495: G = (__v_494 * __v_80); + let __v_496: G = (__v_493 + __v_495); + let __v_497: G = (__v_491 + __v_496); + let __v_498: G = (__v_77 + __v_497); + let __v_499: G = G::from_u64(256); + let __v_500: G = (__v_499 * __v_82); + let __v_501: G = G::from_u64(65536); + let __v_502: G = (__v_501 * __v_83); + let __v_503: G = G::from_u64(16777216); + let __v_504: G = (__v_503 * __v_84); + let __v_505: G = (__v_502 + __v_504); + let __v_506: G = (__v_500 + __v_505); + let __v_507: G = (__v_81 + __v_506); + let __v_508: G = G::from_u64(256); + let __v_509: G = (__v_508 * __v_86); + let __v_510: G = G::from_u64(65536); + let __v_511: G = (__v_510 * __v_87); + let __v_512: G = G::from_u64(16777216); + let __v_513: G = (__v_512 * __v_88); + let __v_514: G = (__v_511 + __v_513); + let __v_515: G = (__v_509 + __v_514); + let __v_516: G = (__v_85 + __v_515); + let __v_517: G = G::from_u64(256); + let __v_518: G = (__v_517 * __v_90); + let __v_519: G = G::from_u64(65536); + let __v_520: G = (__v_519 * __v_91); + let __v_521: G = G::from_u64(16777216); + let __v_522: G = (__v_521 * __v_92); + let __v_523: G = (__v_520 + __v_522); + let __v_524: G = (__v_518 + __v_523); + let __v_525: G = (__v_89 + __v_524); + let __v_526: G = G::from_u64(256); + let __v_527: G = (__v_526 * __v_94); + let __v_528: G = G::from_u64(65536); + let __v_529: G = (__v_528 * __v_95); + let __v_530: G = G::from_u64(16777216); + let __v_531: G = (__v_530 * __v_96); + let __v_532: G = (__v_529 + __v_531); + let __v_533: G = (__v_527 + __v_532); + let __v_534: G = (__v_93 + __v_533); + let __v_535: G = G::from_u64(256); + let __v_536: G = (__v_535 * __v_98); + let __v_537: G = G::from_u64(65536); + let __v_538: G = (__v_537 * __v_99); + let __v_539: G = G::from_u64(16777216); + let __v_540: G = (__v_539 * __v_100); + let __v_541: G = (__v_538 + __v_540); + let __v_542: G = (__v_536 + __v_541); + let __v_543: G = (__v_97 + __v_542); + let __v_544: G = G::from_u64(256); + let __v_545: G = (__v_544 * __v_102); + let __v_546: G = G::from_u64(65536); + let __v_547: G = (__v_546 * __v_103); + let __v_548: G = G::from_u64(16777216); + let __v_549: G = (__v_548 * __v_104); + let __v_550: G = (__v_547 + __v_549); + let __v_551: G = (__v_545 + __v_550); + let __v_552: G = (__v_101 + __v_551); + if (__v_489 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_498 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_498.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_507 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_507.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_516 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_516.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_525 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_525.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_534 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_534.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_543 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_543.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_552 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_552.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_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_553: G = __loaded[0]; + let __v_554: G = __loaded[1]; + let __v_555: G = __loaded[2]; + let __v_556: G = G::from_u64(1); + let __v_557: G = G::from_u64(1); + if (__v_553 != __v_556) { + return Err(ExecError::AssertEqMismatch { lhs: __v_553.as_canonical_u64(), rhs: __v_556.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 88 bytes".to_string()) }); + } + if (__v_554 != __v_557) { + return Err(ExecError::AssertEqMismatch { lhs: __v_554.as_canonical_u64(), rhs: __v_557.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 88 bytes".to_string()) }); + } + if (__v_555 != __v_557) { + return Err(ExecError::AssertEqMismatch { lhs: __v_555.as_canonical_u64(), rhs: __v_557.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 88 bytes".to_string()) }); + } + let __v_558: G = G::from_u64(256); + let __v_559: G = (__v_558 * __v_234); + let __v_560: G = G::from_u64(65536); + let __v_561: G = (__v_560 * __v_235); + let __v_562: G = G::from_u64(16777216); + let __v_563: G = (__v_562 * __v_236); + let __v_564: G = (__v_561 + __v_563); + let __v_565: G = (__v_559 + __v_564); + let __v_566: G = (__v_233 + __v_565); + let __v_567: G = G::from_u64(256); + let __v_568: G = (__v_567 * __v_238); + let __v_569: G = G::from_u64(65536); + let __v_570: G = (__v_569 * __v_239); + let __v_571: G = G::from_u64(16777216); + let __v_572: G = (__v_571 * __v_240); + let __v_573: G = (__v_570 + __v_572); + let __v_574: G = (__v_568 + __v_573); + let __v_575: G = (__v_237 + __v_574); + let __v_576: G = G::from_u64(256); + let __v_577: G = (__v_576 * __v_242); + let __v_578: G = G::from_u64(65536); + let __v_579: G = (__v_578 * __v_243); + let __v_580: G = G::from_u64(16777216); + let __v_581: G = (__v_580 * __v_244); + let __v_582: G = (__v_579 + __v_581); + let __v_583: G = (__v_577 + __v_582); + let __v_584: G = (__v_241 + __v_583); + let __v_585: G = G::from_u64(256); + let __v_586: G = (__v_585 * __v_246); + let __v_587: G = G::from_u64(65536); + let __v_588: G = (__v_587 * __v_247); + let __v_589: G = G::from_u64(16777216); + let __v_590: G = (__v_589 * __v_248); + let __v_591: G = (__v_588 + __v_590); + let __v_592: G = (__v_586 + __v_591); + let __v_593: G = (__v_245 + __v_592); + let __v_594: G = G::from_u64(256); + let __v_595: G = (__v_594 * __v_250); + let __v_596: G = G::from_u64(65536); + let __v_597: G = (__v_596 * __v_251); + let __v_598: G = G::from_u64(16777216); + let __v_599: G = (__v_598 * __v_252); + let __v_600: G = (__v_597 + __v_599); + let __v_601: G = (__v_595 + __v_600); + let __v_602: G = (__v_249 + __v_601); + let __v_603: G = G::from_u64(256); + let __v_604: G = (__v_603 * __v_254); + let __v_605: G = G::from_u64(65536); + let __v_606: G = (__v_605 * __v_255); + let __v_607: G = G::from_u64(16777216); + let __v_608: G = (__v_607 * __v_256); + let __v_609: G = (__v_606 + __v_608); + let __v_610: G = (__v_604 + __v_609); + let __v_611: G = (__v_253 + __v_610); + let __v_612: G = G::from_u64(256); + let __v_613: G = (__v_612 * __v_258); + let __v_614: G = G::from_u64(65536); + let __v_615: G = (__v_614 * __v_259); + let __v_616: G = G::from_u64(16777216); + let __v_617: G = (__v_616 * __v_260); + let __v_618: G = (__v_615 + __v_617); + let __v_619: G = (__v_613 + __v_618); + let __v_620: G = (__v_257 + __v_619); + let __v_621: G = G::from_u64(256); + let __v_622: G = (__v_621 * __v_262); + let __v_623: G = G::from_u64(65536); + let __v_624: G = (__v_623 * __v_263); + let __v_625: G = G::from_u64(16777216); + let __v_626: G = (__v_625 * __v_264); + let __v_627: G = (__v_624 + __v_626); + let __v_628: G = (__v_622 + __v_627); + let __v_629: G = (__v_261 + __v_628); + if (__v_566 != __v_165) { + return Err(ExecError::AssertEqMismatch { lhs: __v_566.as_canonical_u64(), rhs: __v_165.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_575 != __v_166) { + return Err(ExecError::AssertEqMismatch { lhs: __v_575.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_584 != __v_167) { + return Err(ExecError::AssertEqMismatch { lhs: __v_584.as_canonical_u64(), rhs: __v_167.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_593 != __v_168) { + return Err(ExecError::AssertEqMismatch { lhs: __v_593.as_canonical_u64(), rhs: __v_168.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_602 != __v_169) { + return Err(ExecError::AssertEqMismatch { lhs: __v_602.as_canonical_u64(), rhs: __v_169.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_611 != __v_170) { + return Err(ExecError::AssertEqMismatch { lhs: __v_611.as_canonical_u64(), rhs: __v_170.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_620 != __v_171) { + return Err(ExecError::AssertEqMismatch { lhs: __v_620.as_canonical_u64(), rhs: __v_171.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_629 != __v_172) { + return Err(ExecError::AssertEqMismatch { lhs: __v_629.as_canonical_u64(), rhs: __v_172.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_369.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_630: G = __loaded[0]; + let __v_631: G = __loaded[1]; + let __v_632: G = __loaded[2]; + let __v_633: G = G::from_u64(1); + let __v_634: G = G::from_u64(1); + if (__v_630 != __v_633) { + return Err(ExecError::AssertEqMismatch { lhs: __v_630.as_canonical_u64(), rhs: __v_633.as_canonical_u64(), msg: None }); + } + if (__v_631 != __v_634) { + return Err(ExecError::AssertEqMismatch { lhs: __v_631.as_canonical_u64(), rhs: __v_634.as_canonical_u64(), msg: None }); + } + if (__v_632 != __v_634) { + return Err(ExecError::AssertEqMismatch { lhs: __v_632.as_canonical_u64(), rhs: __v_634.as_canonical_u64(), msg: None }); + } + let __v_635: G = G::from_u64(256); + let __v_636: G = (__v_635 * __v_441); + let __v_637: G = G::from_u64(65536); + let __v_638: G = (__v_637 * __v_442); + let __v_639: G = G::from_u64(16777216); + let __v_640: G = (__v_639 * __v_443); + let __v_641: G = (__v_638 + __v_640); + let __v_642: G = (__v_636 + __v_641); + let __v_643: G = (__v_440 + __v_642); + let __v_644: G = G::from_u64(256); + let __v_645: G = (__v_644 * __v_445); + let __v_646: G = G::from_u64(65536); + let __v_647: G = (__v_646 * __v_446); + let __v_648: G = G::from_u64(16777216); + let __v_649: G = (__v_648 * __v_447); + let __v_650: G = (__v_647 + __v_649); + let __v_651: G = (__v_645 + __v_650); + let __v_652: G = (__v_444 + __v_651); + let __v_653: G = G::from_u64(256); + let __v_654: G = (__v_653 * __v_449); + let __v_655: G = G::from_u64(65536); + let __v_656: G = (__v_655 * __v_450); + let __v_657: G = G::from_u64(16777216); + let __v_658: G = (__v_657 * __v_451); + let __v_659: G = (__v_656 + __v_658); + let __v_660: G = (__v_654 + __v_659); + let __v_661: G = (__v_448 + __v_660); + let __v_662: G = G::from_u64(256); + let __v_663: G = (__v_662 * __v_453); + let __v_664: G = G::from_u64(65536); + let __v_665: G = (__v_664 * __v_454); + let __v_666: G = G::from_u64(16777216); + let __v_667: G = (__v_666 * __v_455); + let __v_668: G = (__v_665 + __v_667); + let __v_669: G = (__v_663 + __v_668); + let __v_670: G = (__v_452 + __v_669); + let __v_671: G = G::from_u64(256); + let __v_672: G = (__v_671 * __v_457); + let __v_673: G = G::from_u64(65536); + let __v_674: G = (__v_673 * __v_458); + let __v_675: G = G::from_u64(16777216); + let __v_676: G = (__v_675 * __v_459); + let __v_677: G = (__v_674 + __v_676); + let __v_678: G = (__v_672 + __v_677); + let __v_679: G = (__v_456 + __v_678); + let __v_680: G = G::from_u64(256); + let __v_681: G = (__v_680 * __v_461); + let __v_682: G = G::from_u64(65536); + let __v_683: G = (__v_682 * __v_462); + let __v_684: G = G::from_u64(16777216); + let __v_685: G = (__v_684 * __v_463); + let __v_686: G = (__v_683 + __v_685); + let __v_687: G = (__v_681 + __v_686); + let __v_688: G = (__v_460 + __v_687); + let __v_689: G = G::from_u64(256); + let __v_690: G = (__v_689 * __v_465); + let __v_691: G = G::from_u64(65536); + let __v_692: G = (__v_691 * __v_466); + let __v_693: G = G::from_u64(16777216); + let __v_694: G = (__v_693 * __v_467); + let __v_695: G = (__v_692 + __v_694); + let __v_696: G = (__v_690 + __v_695); + let __v_697: G = (__v_464 + __v_696); + let __v_698: G = G::from_u64(256); + let __v_699: G = (__v_698 * __v_469); + let __v_700: G = G::from_u64(65536); + let __v_701: G = (__v_700 * __v_470); + let __v_702: G = G::from_u64(16777216); + let __v_703: G = (__v_702 * __v_471); + let __v_704: G = (__v_701 + __v_703); + let __v_705: G = (__v_699 + __v_704); + let __v_706: G = (__v_468 + __v_705); + if (__v_643 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_643.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_652 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_652.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_661 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_661.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_670 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_670.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_679 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_679.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_688 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_688.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_697 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_697.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_706 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_706.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + let __ret: [G; OUT_224] = []; + 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 = 16; +const IN_225: usize = 16; +const OUT_225: usize = 0; +fn aiur_fn_225( + inp: [G; IN_225], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_191], ExecError> { +) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18218,49 +22940,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 +22992,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 +23011,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 +23063,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 +23098,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 +23109,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 +23120,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 +23131,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 +23142,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 +23153,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 +23164,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 +23192,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,20 +23203,20 @@ 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_241, __v_261]; 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_262: G = __r_arr[0]; let __v_263: G = G::from_u64(2); let __v_264: G = G::from_u64(0); @@ -18502,7 +23224,7 @@ fn aiur_fn_191( 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_267, __v_265, __v_266]; 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_268: G = __r_arr[0]; let __v_269: G = G::from_u64(103); let __v_270: G = G::from_u64(230); @@ -18554,9 +23276,9 @@ fn aiur_fn_191( 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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_268, __v_303, __v_304, __v_305, __v_314, __v_315, __v_318]; 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_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 __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_319]; 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_320: G = __r_arr[0]; let __v_321: G = __r_arr[1]; let __v_322: G = __r_arr[2]; @@ -18589,37 +23311,37 @@ fn aiur_fn_191( 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 __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_268]; 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_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 __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_353, __v_352]; 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_354: G = __r_arr[0]; let __v_355: 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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_30]; 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_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 __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_62]; 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_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 __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_64]; 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_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 __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_57]; 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_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 __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_362: G = __r_arr[0]; let __v_363: G = G::from_u64(1); if (__v_362 != __v_363) { @@ -18637,9 +23359,9 @@ fn aiur_fn_191( _ => { 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 __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_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 __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_358: G = __r_arr[0]; match __v_24.as_canonical_u64() { _ => { @@ -18659,15 +23381,15 @@ 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 __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_34, __v_268]; 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_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 __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_24, __v_360]; 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_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 __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_359, __v_361]; 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_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 __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_22, __v_362]; 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_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 __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_262, __v_363]; 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_364: G = __r_arr[0]; let __v_365: G = G::from_u64(0); let __v_366: G = G::from_u64(109); @@ -18714,7 +23436,7 @@ fn aiur_fn_191( 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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_406, __v_409]; 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_410: G = __r_arr[0]; let __v_411: G = __r_arr[1]; let __v_412: G = __r_arr[2]; @@ -18736,16 +23458,16 @@ fn aiur_fn_191( 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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_426, __v_432]; 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_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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_433, __v_436]; 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_437: G = __r_arr[0]; let __v_438: G = __r_arr[1]; let __v_439: G = __r_arr[2]; @@ -18767,25 +23489,25 @@ fn aiur_fn_191( 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_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_453, __v_459]; 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_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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_460, __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_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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_30, __v_464]; 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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_461, __v_465]; 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_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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_466, __v_469]; 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_470: G = __r_arr[0]; let __v_471: G = __r_arr[1]; let __v_472: G = __r_arr[2]; @@ -18804,12 +23526,12 @@ fn aiur_fn_191( 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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_486, __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_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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_488, __v_491]; 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_492: G = __r_arr[0]; let __v_493: G = __r_arr[1]; let __v_494: G = __r_arr[2]; @@ -18998,17 +23720,17 @@ fn aiur_fn_191( 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 __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_678, __v_679, __v_354, __v_530, __v_551, __v_572, __v_593]; 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_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 __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__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[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_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 __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_357]; 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_684: 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 __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_38]; 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_685: G = __r_arr[0]; let __v_686: G = G::from_u64(1); let __v_687: G = G::from_u64(1); @@ -19018,7 +23740,7 @@ fn aiur_fn_191( break '__mc_3 [__v_688]; }, 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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_60, __v_688]; 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_689: G = __r_arr[0]; break '__mc_3 [__v_689]; }, @@ -19028,18 +23750,18 @@ fn aiur_fn_191( } }; 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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_57, __v_689]; 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_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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_64, __v_690]; 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_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 __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_62, __v_691]; 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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_508, __v_692]; 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_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 __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_693, __v_696]; 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_697: G = __r_arr[0]; let __v_698: G = __r_arr[1]; let __v_699: G = __r_arr[2]; @@ -19100,31 +23822,31 @@ fn aiur_fn_191( 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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_713, __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_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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_46, __v_761]; 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_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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_758, __v_762]; 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_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 __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_763, __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_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 __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__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[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_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 __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_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 __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_238] = { let __args: [G; IN_238] = [__v_22]; 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_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 __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_252]; 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_771: G = __r_arr[0]; let __v_772: G = (__v_770 - __v_771); let __v_773: G = G::from_bool((__v_772 == G::ZERO)); @@ -19132,9 +23854,9 @@ fn aiur_fn_191( 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_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 __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_357]; 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_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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_30]; 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_776: G = __r_arr[0]; let __v_777: G = (__v_775 - __v_776); let __v_778: G = G::from_bool((__v_777 == G::ZERO)); @@ -19142,7 +23864,7 @@ fn aiur_fn_191( 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_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_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_780: G = __r_arr[0]; let __v_781: G = (__v_780 - __v_685); let __v_782: G = G::from_bool((__v_781 == G::ZERO)); @@ -19150,7 +23872,7 @@ fn aiur_fn_191( 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_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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_44]; 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_784: G = __r_arr[0]; let __v_785: G = (__v_784 - __v_195); let __v_786: G = G::from_bool((__v_785 == G::ZERO)); @@ -19158,7 +23880,7 @@ fn aiur_fn_191( 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_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 __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_46]; 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_788: G = __r_arr[0]; let __v_789: G = G::from_u64(1); if (__v_788 != __v_789) { @@ -19170,7 +23892,7 @@ fn aiur_fn_191( if (__v_791 != __v_792) { return Err(ExecError::AssertEqMismatch { lhs: __v_791.as_canonical_u64(), rhs: __v_792.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_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 __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__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[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_793: G = __r_arr[0]; break '__mc_1 [__v_793]; }, @@ -19419,25 +24141,25 @@ fn aiur_fn_191( 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 __ret: [G; OUT_225] = []; + 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_192: usize = 2; -const IN_192: usize = 2; -const OUT_192: usize = 1; -fn aiur_fn_192( - inp: [G; IN_192], +const INPUT_SIZE_226: usize = 2; +const IN_226: usize = 2; +const OUT_226: usize = 1; +fn aiur_fn_226( + inp: [G; IN_226], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_192], ExecError> { +) -> 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 __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_233] = { let __args: [G; IN_233] = [__v_0, __v_1]; 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_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 +24167,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_226] = [__v_4]; + 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); }, _ => { @@ -19456,15 +24178,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_227: usize = 1; +const IN_227: usize = 1; +const OUT_227: usize = 1; +fn aiur_fn_227( + inp: [G; IN_227], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_193], ExecError> { +) -> Result<[G; OUT_227], 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 +24196,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_227] = [__v_4]; + 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); }, 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_227] = [__v_4]; + 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); }, _ => { @@ -19491,19 +24213,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_228: usize = 2; +const IN_228: usize = 2; +const OUT_228: usize = 2; +fn aiur_fn_228( + inp: [G; IN_228], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_194], ExecError> { +) -> 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 __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_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_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 +24234,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_228] = [__v_4, __v_5]; + 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); }, _ => { @@ -19523,15 +24245,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_229: usize = 1; +const IN_229: usize = 1; +const OUT_229: usize = 1; +fn aiur_fn_229( + inp: [G; IN_229], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_195], ExecError> { +) -> Result<[G; OUT_229], 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 +24265,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_229] = [__v_6]; + 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); }, 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_229] = { let __args: [G; IN_229] = [__v_5]; 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 __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_229] = [__v_8]; + 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); }, _ => { @@ -19563,15 +24285,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_230: usize = 1; +const IN_230: usize = 1; +const OUT_230: usize = 1; +fn aiur_fn_230( + inp: [G; IN_230], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_196], ExecError> { +) -> Result<[G; OUT_230], 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 +24304,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_230] = [__v_5]; + 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); }, 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_230] = { let __args: [G; IN_230] = [__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_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_230] = [__v_7]; + 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); }, _ => { @@ -19602,15 +24324,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_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_197], ExecError> { +) -> 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]; @@ -19627,17 +24349,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_231] = [__v_1]; + 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_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_231] = { let __args: [G; IN_231] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __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_231] = [__v_14]; + 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); }, _ => { @@ -19647,15 +24369,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_232: usize = 2; +const IN_232: usize = 2; +const OUT_232: usize = 1; +fn aiur_fn_232( + inp: [G; IN_232], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_198], 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]; @@ -19665,17 +24387,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_232] = [__v_1]; + 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_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_232] = { let __args: [G; IN_232] = [__v_4, __v_1]; 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_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_232] = [__v_7]; + 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); }, _ => { @@ -19685,28 +24407,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_233: usize = 2; +const IN_233: usize = 2; +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_199], ExecError> { +) -> 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]; 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_233] = [__v_0]; + 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); }, _ => { 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_233] = { let __args: [G; IN_233] = [__v_0, __v_3]; 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_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 +24436,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_233] = [__v_7]; + 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); }, _ => { @@ -19727,15 +24449,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_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_200], ExecError> { +) -> Result<[G; OUT_234], 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 +24471,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_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); }, 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_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_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_234] = [__v_10]; + 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); }, _ => { @@ -19769,15 +24491,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_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_201], ExecError> { +) -> Result<[G; OUT_235], 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 +24516,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_235] = [__v_11]; + 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_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_235] = { let __args: [G; IN_235] = [__v_10]; 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_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_235] = [__v_13]; + 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); }, _ => { @@ -19814,19 +24536,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_236: usize = 2; +const IN_236: usize = 2; +const OUT_236: usize = 4; +fn aiur_fn_236( + inp: [G; IN_236], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_202], 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]; - 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_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_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 +24559,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_236] = [__v_4, __v_5, __v_6, __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); }, _ => { @@ -19848,15 +24570,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_237: usize = 1; +const IN_237: usize = 1; +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_203], ExecError> { +) -> Result<[G; OUT_237], 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 +24593,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_237] = [__v_9]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; 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_237] = { let __args: [G; IN_237] = [__v_8]; 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_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_237] = [__v_11]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19891,15 +24613,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_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_204], ExecError> { +) -> Result<[G; OUT_238], 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 +24631,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_238] = [__v_4]; + 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_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_238] = { let __args: [G; IN_238] = [__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 __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_238] = [__v_6]; + 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); }, _ => { @@ -19929,28 +24651,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_239: usize = 2; +const IN_239: usize = 2; +const OUT_239: usize = 8; +fn aiur_fn_239( + inp: [G; IN_239], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_205], ExecError> { +) -> Result<[G; OUT_239], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __v_1]; 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_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_239] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __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); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_240: usize = 2; +const IN_240: usize = 2; +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 __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_240] = [__v_0]; + 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); }, _ => { 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_240] = { let __args: [G; IN_240] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __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 +24719,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_240] = [__v_8]; + 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); }, _ => { @@ -19972,28 +24732,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_241: usize = 2; +const IN_241: usize = 2; +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_206], ExecError> { +) -> 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]; 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_241] = [__v_0]; + 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); }, _ => { 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_241] = { let __args: [G; IN_241] = [__v_0, __v_3]; 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_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 +24764,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_241] = [__v_10]; + 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_5.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_242: usize = 2; +const IN_242: usize = 2; +const OUT_242: usize = 1; +fn aiur_fn_242( + inp: [G; IN_242], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_242], 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_242] = [__v_0]; + 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); + }, + _ => { + let __v_2: G = G::from_u64(1); + let __v_3: G = (__v_1 - __v_2); + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __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 __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_242] = [__v_14]; + 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); }, _ => { @@ -21059,6 +25868,186 @@ 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()); + }, _ => { 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..c124d03f2 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs @@ -24,6 +24,161 @@ 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], +} + +/// 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>], +} + +/// 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>, 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>, String> { + decode_keyed_blobs(blob, "join trees").map(|entries| { + entries.into_iter().map(|(root, bytes)| JoinTree { root, bytes }).collect() + }) +} + +fn decode_keyed_blobs<'a>( + blob: &'a [u8], + label: &str, +) -> Result, 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 { + 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, 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 { + 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 { + digest + .chunks_exact(4) + .map(|word| { + G::from_u32(u32::from_le_bytes(word.try_into().expect("four-byte chunk"))) + }) + .collect() +} + +/// A 32-byte address as 32 field elements, matching the IxVM tree-loader key. +#[inline] +fn address_key(address: &[u8; 32]) -> Vec { + 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 +216,137 @@ 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 = 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 `join_two`'s six-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. +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); + } + + io +} + +#[cfg(test)] +mod tests { + use super::*; + use multi_stark::p3_field::PrimeField64; + + fn info(io: &IOBuffer, channel: u8, key: Vec) -> (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 { + 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 advice = JoinAdvice { + proofs: [&[1, 2], &[3]], + recursion_vk: &[4, 5], + child_claims: [&[6], &[7, 8]], + output_claim: &[9], + allowed: &[10], + preimages: &preimages, + trees: &trees, + }; + + 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_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]); + + blob.push(11); + assert!(decode_join_preimages(&blob).is_err()); + assert!(decode_join_trees(&[1, 0, 0]).is_err()); + } +} From c83f6d92348e4f6dc3ecc1791ca39bcdd1c71ac4 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Fri, 28 Aug 2026 05:43:51 -0400 Subject: [PATCH 02/44] feat: add structural aggregate joins --- Ix/Aiur/Protocol.lean | 9 +- Ix/Aiur/Semantics/BytecodeFfi.lean | 11 +- Ix/Cli/AggregateCmd.lean | 134 +- Ix/Cli/CheckCmd.lean | 16 + Ix/Cli/VerifyCmd.lean | 163 +- Ix/MultiStark.lean | 56 +- Ix/MultiStark/Aggregate.lean | 182 +- Ix/MultiStark/Host.lean | 58 +- Tests/MultiStark.lean | 190 +- crates/ffi/src/aiur/protocol.rs | 18 +- crates/ixvm-codegen/src/aiur_multi_stark.rs | 3437 +++++++++++------ .../src/aiur_multi_stark_runner.rs | 43 +- 12 files changed, 3113 insertions(+), 1204 deletions(-) diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 73c56f844..322ebad65 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -154,9 +154,10 @@ opaque proveMultiStark (system : @& AiurSystem) (proofBytes vkBytes claimBytes : @& ByteArray) (useBytecode : Bool := false) : Array G × Proof -/-- Prove one aggregate-first binary join over raw child proof/claim advice. -The compact preimage/tree blobs are produced by -`MultiStark.joinPreimagesBlob` and `MultiStark.joinTreesBlob`. Malformed +/-- Prove one flat or structural aggregate-first binary join over raw child +proof/claim advice. 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. -/ @@ -165,7 +166,7 @@ opaque proveMultiStarkJoin (system : @& AiurSystem) (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G) (leftProofBytes rightProofBytes recursionVkBytes : @& ByteArray) (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray) - (preimagesBlob treesBlob : @& ByteArray) (useBytecode : Bool := false) : + (preimagesBlob treesBlob pathsBlob : @& ByteArray) (useBytecode : Bool := false) : Except String (Array G × Proof) @[extern "rs_aiur_system_prove_addr_with_env"] diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index 08e8b9878..caf215306 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -174,19 +174,20 @@ opaque executeMultiStark (toplevel : @& Bytecode.Toplevel) (proofBytes vkBytes claimBytes : @& ByteArray) (useBytecode : Bool := false) : Except String (Array G × Array QueryCount) -/-- Native execution of the aggregate-first `join_two` entrypoint. The two +/-- Native execution of either aggregate-first join entrypoint. The two child proofs/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`; Rust expands them directly into IO channels 4 and -5. As with `executeMultiStark`, `useBytecode` selects the generic interpreter -over the generated production verifier. -/ +`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) (leftProofBytes rightProofBytes recursionVkBytes : @& ByteArray) (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray) - (preimagesBlob treesBlob : @& ByteArray) (useBytecode : Bool := false) : + (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 index 06379a352..e1f54877c 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -3,8 +3,10 @@ Bind persisted shard proof wrappers to every shard in a manifest, lift each IxVM proof into the Multi-STARK recursion system, then execute/prove binary - joins in the manifest's bisection-tree order. The final persisted wrapper - carries the aggregate `CheckEnv` claim and recursive proof bytes. + joins in the manifest's bisection-tree order. Small joins use flat canonical + subjects; joins above `--structural-above` use an O(1) root-of-roots subject + fold plus assumption-membership paths. The final persisted wrapper carries + the aggregate `CheckEnv` claim and recursive proof bytes. This first host driver is intentionally serial and cache-free. Its slot model and content-addressed inputs make parallel scheduling and resumable @@ -30,12 +32,47 @@ structure PreparedShard where structure AggregateSlot where statement : MultiStark.CheckEnvTrees + subjectCount : Nat outerClaim : Array Aiur.G proof : Aiur.Proof /-- Preimages needed when this slot is decoded by its parent. A lift exposes its inner claims plus `CheckEnv`; a join exposes only its output `CheckEnv`. -/ openPreimages : Array ByteArray +/-- 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 + deriving BEq, Repr + +def defaultStructuralAbove : Nat := 4096 + +/-- 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) : + Except String (Array ScheduledFold) := do + let mut scheduled : Array ScheduledFold := #[] + for op in plan do + match op with + | .leaf shard => + let some count := shardCounts[shard]? + | throw s!"aggregate plan references missing shard {shard}" + scheduled := scheduled.push { op, subjectCount := count, structural := false } + | .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 + scheduled := scheduled.push { + op, subjectCount := count, structural := count > structuralAbove + } + pure scheduled + private def addrOfHex (label value : String) : Except String Address := match Address.fromString value with | some address => .ok address @@ -58,15 +95,21 @@ private def compileToplevel (label : String) | .error e => return Except.error s!"{label} compilation failed: {e}" | .ok compiled => return Except.ok compiled -private def printPlan (plan : Array Ix.Cli.CheckCmd.AggregationTree.FoldOp) : IO Unit := do - let leaves := plan.countP fun op => match op with +private def printPlan (plan : Array ScheduledFold) (structuralAbove : Nat) : IO Unit := do + let lifts := plan.countP fun item => match item.op with | .leaf _ => true | .join _ _ => false - IO.println s!"[aggregate] plan: {leaves} lifts + {plan.size - leaves} binary joins" - for (op, slot) in plan.mapIdx fun slot op => (op, slot) do - match op with - | .leaf shard => IO.println s!" slot {slot}: lift shard {shard}" - | .join left right => IO.println s!" slot {slot}: join slots {left}, {right}" + let structural := plan.countP (·.structural) + IO.println s!"[aggregate] plan: {lifts} lifts + {plan.size - lifts} 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 => + IO.println s!" slot {slot}: lift shard {shard} ({item.subjectCount} subjects)" + | .join left right => + let mode := if item.structural then "structural" else "flat" + IO.println s!" slot {slot}: {mode} join slots {left}, {right} \ + ({item.subjectCount} subjects)" def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do let some ixePath := (p.flag? "ixe").map (·.as! String) | do @@ -87,12 +130,17 @@ def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do if view.shards.size < 2 then IO.eprintln "aggregate currently requires at least two shards (single-shard lift packaging is not yet exposed)" return 1 - if view.shards.any (·.isEmpty) then + let shardCounts := Ix.Cli.CheckCmd.ownedConstCountsForShards env view.shards + if shardCounts.any (· == 0) then IO.eprintln "aggregate currently requires non-empty shards; regenerate or prune empty manifest leaves" return 1 - let plan := view.aggregationTree.foldPlan - printPlan plan + let structuralAbove := ((p.flag? "structural-above").map (·.as! Nat)).getD + defaultStructuralAbove + let plan ← match schedulePlan view.aggregationTree.foldPlan shardCounts structuralAbove with + | .error e => IO.eprintln e; return 1 + | .ok plan => pure plan + printPlan plan structuralAbove if p.hasFlag "plan-only" then return 0 let proofHexes := (p.variableArgsAs! String).toList @@ -153,25 +201,31 @@ def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do let verifyIdx := ixvmCompiled.getFuncIdx `verify_claim |>.get! let liftIdx := recursionCompiled.getFuncIdx `verify_multi_stark_proof |>.get! let joinIdx := recursionCompiled.getFuncIdx `join_two |>.get! + let structuralJoinIdx := recursionCompiled.getFuncIdx `join_two_structural |>.get! let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode Aiur.defaultCommitmentParameters Aiur.defaultFriParameters let recursionSystem := Aiur.AiurSystem.build recursionCompiled.bytecode Aiur.defaultCommitmentParameters Aiur.defaultFriParameters let ixvmVk := ixvmSystem.vkBytes let recursionVk := recursionSystem.vkBytes - let allowed := MultiStark.allowedBlob ixvmVk verifyIdx recursionVk liftIdx joinIdx + let allowed := MultiStark.allowedBlob ixvmVk verifyIdx recursionVk liftIdx + joinIdx structuralJoinIdx let mut slots : Array AggregateSlot := #[] - for (op, slotIdx) in plan.mapIdx fun slotIdx op => (op, slotIdx) do - match op with + for (item, slotIdx) in plan.mapIdx fun slotIdx item => (item, slotIdx) do + match item.op with | .leaf shard => let some wrapper := proofsByShard.get? shard | do IO.eprintln s!"internal: no proof for shard {shard}" return 1 - let some item := prepared[shard]? | do + let some preparedShard := prepared[shard]? | do IO.eprintln s!"internal: no statement for shard {shard}" return 1 - let claimBytes := Ix.Claim.ser item.claim + if preparedShard.statement.subjectCount != item.subjectCount then + IO.eprintln s!"internal: shard {shard} has {preparedShard.statement.subjectCount} \ + reconstructed subjects, but the schedule records {item.subjectCount}" + return 1 + let claimBytes := Ix.Claim.ser preparedShard.claim let verifyInput := IxVM.ClaimHarness.packedDigestKey (Address.blake3 claimBytes) let innerClaim := Aiur.buildClaim verifyIdx verifyInput #[] @@ -188,7 +242,8 @@ def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do let (outerClaim, proof) := recursionSystem.proveMultiStark liftIdx pubInput wrapper.proof ixvmVk innerClaimsBytes slots := slots.push { - statement := item.statement + statement := preparedShard.statement + subjectCount := item.subjectCount outerClaim proof openPreimages := #[innerClaimsBytes, claimBytes] @@ -200,26 +255,49 @@ def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do let some right := slots[rightIdx]? | do IO.eprintln s!"invalid aggregate plan: missing right slot {rightIdx}" return 1 - let output := left.statement.join right.statement + if left.subjectCount + right.subjectCount != item.subjectCount then + IO.eprintln s!"internal: join slot {slotIdx} has inconsistent scheduled subject counts" + return 1 + let output := if item.structural then + left.statement.joinStructural right.statement + else + left.statement.join right.statement + if output.subjectCount != item.subjectCount then + IO.eprintln s!"internal: join slot {slotIdx} reconstructed {output.subjectCount} \ + subjects, but the schedule records {item.subjectCount}" + return 1 let outputClaimBytes := Ix.Claim.ser output.claim let pubInput := MultiStark.joinPubInput allowed outputClaimBytes let leftClaimsBytes := MultiStark.serializeClaims #[left.outerClaim] let rightClaimsBytes := MultiStark.serializeClaims #[right.outerClaim] let preimagesBlob := MultiStark.joinPreimagesBlob (left.openPreimages ++ right.openPreimages) - let treesBlob := MultiStark.joinTreesBlob - (MultiStark.CheckEnvTrees.adviceTrees left.statement right.statement output) - IO.println s!"[aggregate] joining slots {leftIdx}, {rightIdx} into {slotIdx}" + let trees := if item.structural then + MultiStark.CheckEnvTrees.structuralAdviceTrees + left.statement right.statement output + else + MultiStark.CheckEnvTrees.adviceTrees left.statement right.statement output + let treesBlob := MultiStark.joinTreesBlob trees + let pathsBlob := if item.structural then + MultiStark.joinPathsBlob + (MultiStark.CheckEnvTrees.structuralPathAdvice + left.statement right.statement output) + else + MultiStark.joinPathsBlob #[] + let joinFunIdx := if item.structural then structuralJoinIdx else joinIdx + let mode := if item.structural then "structural" else "flat" + IO.println s!"[aggregate] {mode}-joining slots {leftIdx}, {rightIdx} into {slotIdx}" (← IO.getStdout).flush - let result := recursionSystem.proveMultiStarkJoin joinIdx pubInput + let result := recursionSystem.proveMultiStarkJoin joinFunIdx pubInput left.proof.toBytes right.proof.toBytes recursionVk leftClaimsBytes rightClaimsBytes outputClaimBytes allowed - preimagesBlob treesBlob + preimagesBlob treesBlob pathsBlob let (outerClaim, proof) ← match result with | .error e => IO.eprintln s!"join slot {slotIdx}: {e}"; return 1 | .ok result => pure result slots := slots.push { statement := output + subjectCount := item.subjectCount outerClaim proof openPreimages := #[outputClaimBytes] @@ -231,8 +309,11 @@ def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do let some envTree := IxVM.ClaimHarness.envCanonicalTree env | do IO.eprintln "cannot aggregate an empty environment" return 1 - if root.statement.subjects.root != envTree.root then - IO.eprintln s!"aggregate root {root.statement.subjects.root} does not match env root {envTree.root}" + 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)}" @@ -259,6 +340,7 @@ def aggregateCmd : Cli.Cmd := `[Cli| "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 lift/join slot plan without loading or proving shard proofs." + "structural-above" : Nat; "Use structural joins when a node contains more than N subject leaves (default 4096; 0 means every join)." ARGS: ...proofs : String; "Persisted shard-proof wrapper addresses, in any order (exactly one per shard unless --plan-only)." diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 72a007b11..d26603d92 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -579,6 +579,22 @@ 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 + /-- 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. -/ diff --git a/Ix/Cli/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean index 44185527d..a6490adfb 100644 --- a/Ix/Cli/VerifyCmd.lean +++ b/Ix/Cli/VerifyCmd.lean @@ -20,6 +20,7 @@ public import Ix.IxVM.Toplevel public import Ix.IxVM.ClaimHarness public import Ix.MultiStark public import Ix.Store +public import Ix.Cli.AggregateCmd public import Ix.Cli.CheckCmd public section @@ -80,10 +81,25 @@ 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 + flatJoinIdx : Aiur.Bytecode.FunIdx + structuralJoinIdx : Aiur.Bytecode.FunIdx + allowed : ByteArray + +inductive AggregateRootKind where + | flat + | structural + deriving BEq, Repr + +structure ExpectedAggregate where + claim : Ix.Claim + kind : AggregateRootKind + /-- Build the two deterministic systems whose identities are committed by an aggregate root: the IxVM vk and the combined lift/join recursion vk. -/ private def buildAggregateBackend : - IO (Except String (Aiur.AiurSystem × Aiur.Bytecode.FunIdx × ByteArray)) := do + 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 @@ -97,43 +113,97 @@ private def buildAggregateBackend : let verifyIdx := ixvmCompiled.getFuncIdx `verify_claim |>.get! let liftIdx := recursionCompiled.getFuncIdx `verify_multi_stark_proof |>.get! let joinIdx := recursionCompiled.getFuncIdx `join_two |>.get! + let structuralJoinIdx := recursionCompiled.getFuncIdx `join_two_structural |>.get! let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode commitmentParameters friParameters let recursionSystem := Aiur.AiurSystem.build recursionCompiled.bytecode commitmentParameters friParameters let recursionVk := recursionSystem.vkBytes let allowed := MultiStark.allowedBlob ixvmSystem.vkBytes verifyIdx - recursionVk liftIdx joinIdx - return .ok (recursionSystem, joinIdx, allowed) + recursionVk liftIdx joinIdx structuralJoinIdx + return .ok { + system := recursionSystem + flatJoinIdx := joinIdx + structuralJoinIdx + allowed + } + +private def shardStatement (env : Ixon.Env) (blocks : Array Address) : + Except String MultiStark.CheckEnvTrees := do + let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks env blocks + let (claim, _, trees) ← IxVM.ClaimHarness.shardCheckEnvClaim env owned + MultiStark.CheckEnvTrees.ofClaim claim trees + +/-- Reproduce the hybrid flat/structural statement fold from the manifest. +The threshold schedule is shared with `ix aggregate`; no proof data is needed. -/ +private def expectedFromManifest (env : Ixon.Env) + (view : Ix.Cli.CheckCmd.IxesManifestView) (structuralAbove : Nat) : + Except String (MultiStark.CheckEnvTrees × AggregateRootKind) := do + if view.shards.size < 2 then + throw "aggregate verification requires a manifest with at least two shards" + let counts := Ix.Cli.CheckCmd.ownedConstCountsForShards env view.shards + if counts.any (· == 0) then + throw "aggregate verification requires non-empty shards" + let plan ← Ix.Cli.AggregateCmd.schedulePlan view.aggregationTree.foldPlan + counts structuralAbove + let mut slots : Array MultiStark.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" + let some rootPlan := plan.back? | throw "aggregate manifest produced no root slot" + pure (root, if rootPlan.structural then .structural else .flat) private def verifyAggregateProof (recursionSystem : Aiur.AiurSystem) - (joinIdx : Aiur.Bytecode.FunIdx) (allowed : ByteArray) - (expectedEnv? : Option Ixon.Env) (proofAddr : Address) : IO UInt32 := do + (flatJoinIdx structuralJoinIdx : Aiur.Bytecode.FunIdx) (allowed : ByteArray) + (expected? : Option ExpectedAggregate) (proofAddr : Address) : IO UInt32 := do let wrapper ← IO.ofExcept (Ixon.Proof.de (← StoreIO.toIO (Store.read proofAddr))) - let .checkEnv root assumptions := wrapper.claim | do + let .checkEnv _ _ := wrapper.claim | do IO.eprintln s!"error: aggregate proof {proofAddr} does not bundle a CheckEnv claim" return 1 - match expectedEnv? with - | some env => - let some expectedTree := IxVM.ClaimHarness.envCanonicalTree env | do - IO.eprintln "error: cannot verify an aggregate against an empty environment" - return 1 - if root != expectedTree.root then - IO.eprintln s!"error: aggregate subject root {root} does not match env root {expectedTree.root}" - return 1 - if assumptions.isSome then - IO.eprintln s!"error: aggregate retains assumptions {assumptions}" + 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 claimBytes := Ix.Claim.ser wrapper.claim let pubInput := MultiStark.joinPubInput allowed claimBytes - let outerClaim := Aiur.buildClaim joinIdx pubInput #[] - match recursionSystem.verify outerClaim (Aiur.Proof.ofBytes wrapper.proof) with + let proof := Aiur.Proof.ofBytes wrapper.proof + let verifyAt (idx : Aiur.Bytecode.FunIdx) := + recursionSystem.verify (Aiur.buildClaim idx pubInput #[]) proof + let result : Except String AggregateRootKind := match expected? with + | some expected => + let idx := match expected.kind with + | .flat => flatJoinIdx + | .structural => structuralJoinIdx + (verifyAt idx).map fun _ => expected.kind + | none => + match verifyAt flatJoinIdx with + | .ok () => .ok .flat + | .error flatError => match verifyAt structuralJoinIdx with + | .ok () => .ok .structural + | .error structuralError => .error + s!"flat join: {flatError}; structural join: {structuralError}" + match result with | .error e => IO.eprintln s!"error: aggregate verification failed: {e}" return 1 - | .ok () => - IO.println s!"ok: aggregate proof {proofAddr} verifies {wrapper.claim}" + | .ok kind => + let label := match kind with | .flat => "flat" | .structural => "structural" + IO.println s!"ok: {label} aggregate proof {proofAddr} verifies {wrapper.claim}" return 0 /-- Shard-aware verification (parity with `check`/`prove`): @@ -209,18 +279,52 @@ def runVerifyCmd (p : Cli.Parsed) : IO UInt32 := do if proofs.isEmpty then p.printError "error: --aggregate requires at least one aggregate proof address" return 1 - let expectedEnv? ← match (p.flag? "ixe").map (·.as! String) with - | none => pure none - | some path => match Ixon.deEnvAnon (← IO.FS.readBinFile path) with - | .error e => IO.eprintln s!"deserialize {path} failed: {e}"; return 1 - | .ok env => pure (some env) - let (recursionSystem, joinIdx, allowed) ← match ← buildAggregateBackend with + 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 + kind := .flat + }) + | 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, kind) ← 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, kind }) + | none, some _ => unreachable! + let backend ← match ← buildAggregateBackend 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 recursionSystem joinIdx allowed expectedEnv? proofAddr) != 0 then + if (← verifyAggregateProof backend.system backend.flatJoinIdx + backend.structuralJoinIdx backend.allowed expected? proofAddr) != 0 then rc := 1 return rc match (p.flag? "ixe").map (·.as! String), (p.flag? "ixes").map (·.as! String) with @@ -248,9 +352,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 proof arguments as aggregate-first recursive roots. Rebuilds and pins both vks; with --ixe, also requires an unconditional claim for that exact env root." + "aggregate"; "Interpret proof arguments as aggregate-first recursive roots. With --ixe alone, expects an all-flat canonical root; add --ixes for hybrid structural roots." + "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/MultiStark.lean b/Ix/MultiStark.lean index 656c72b1f..ba5be06fa 100644 --- a/Ix/MultiStark.lean +++ b/Ix/MultiStark.lean @@ -34,9 +34,10 @@ 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 second production entrypoint, `join_two`, verifies two lift/join proofs -under one pinned recursion vk and folds their `CheckEnv` statements by -canonical subject union and assumption discharge. Its implementation lives in +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`, @@ -111,14 +112,15 @@ def multiStarkFull : Except Aiur.Global Aiur.Source.Toplevel := do t.merge entrypoints /-- The production recursion toplevel: `multiStarkFull` pruned to the combined -call closures of `verify_multi_stark_proof` (lift) and `join_two`. Every +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, `join_two]) + pure (t.prune [`verify_multi_stark_proof, `join_two, `join_two_structural]) /-! ## Lean-side input assembly @@ -159,30 +161,32 @@ def verifierPubInput (vkBytes claimBytes : ByteArray) : Array Aiur.G := /-! ## Aggregate-first input assembly -These helpers define the host half of the `join_two` wire contract from +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 88-byte allowlist preimage for a recursive join: +/-- 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 ‖ join index as u64-LE`. +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 three +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 : Nat) : ByteArray := + (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 liftIdx ++ u64le joinIdx ++ u64le structuralJoinIdx⟩ -/-- Public input for `join_two`: the packed Blake3 digest of the allowlist -blob followed by the packed digest of the output `CheckEnv` claim bytes. -/ +/-- 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 @@ -222,6 +226,32 @@ 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 index 26bc140b9..23c46119a 100644 --- a/Ix/MultiStark/Aggregate.lean +++ b/Ix/MultiStark/Aggregate.lean @@ -15,6 +15,11 @@ sets behind their roots, and emit `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. @@ -384,6 +389,86 @@ def aggregate := ⟦ } } + /- ## 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 { @@ -483,12 +568,13 @@ def aggregate := ⟦ join_parse_check_env(join_load_preimage(check_env_digest)) } - -- Decode a verified child as either a lift or a transitive join. Function + -- 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) + 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, @@ -501,8 +587,13 @@ def aggregate := ⟦ join_assert_digest(join_claim_digest(outer, 2), ixvm_vk_digest); join_decode_lift_claim(outer, verify_claim_idx), _ => - assert_eq!(child_idx, join_idx, - "join: child is neither lift nor join"); + 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)), @@ -518,8 +609,11 @@ def aggregate := ⟦ 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). + -- 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"); @@ -527,14 +621,16 @@ def aggregate := ⟦ 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, astop) = @read_u64(as4); + 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 88 bytes"); + "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. @@ -548,9 +644,11 @@ def aggregate := ⟦ 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); + 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); + 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]); @@ -571,6 +669,72 @@ def aggregate := ⟦ 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 diff --git a/Ix/MultiStark/Host.lean b/Ix/MultiStark/Host.lean index cdc0d86f1..28e278b9c 100644 --- a/Ix/MultiStark/Host.lean +++ b/Ix/MultiStark/Host.lean @@ -6,18 +6,20 @@ public import Std.Data.HashSet /-! # Host-side aggregate-first statement folding -The circuit rechecks all of this from serialized trees. These helpers give the -CLI one canonical implementation for constructing its claimed output and the -six tree preimages supplied to `join_two`. +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 canonical trees whose roots it -commits to. `assumptions = none` is represented by no tree, never by an empty -or padding-only serialization. -/ +/-- 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 @@ -28,6 +30,9 @@ 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 @@ -56,6 +61,17 @@ def ofClaim (claim : Ix.Claim) 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` @@ -69,12 +85,29 @@ def join (left right : CheckEnvTrees) : CheckEnvTrees := let subjects := (Ix.AssumptionTree.canonical subjectLeaves).get! let subjectSet := subjects.leaves.foldl (fun set addr => set.insert addr) ({} : Std.HashSet Address) - let leftAssumptions := left.assumptions.map (·.leaves) |>.getD #[] - let rightAssumptions := right.assumptions.map (·.leaves) |>.getD #[] - let remaining := (leftAssumptions ++ rightAssumptions).filter + 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 := @@ -82,6 +115,13 @@ def adviceTrees (left right output : CheckEnvTrees) : Array Ix.AssumptionTree := #[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 diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index 81fa42536..942e0f69b 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -5,6 +5,7 @@ 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.Claim public import Ix.AssumptionTree @@ -234,7 +235,7 @@ def endToEndSuite : IO UInt32 := do -- `aggregate-first`: execute a real two-child canonical set-discharge join -- ═════════════════════════════════════════════════════════════════════════════ -/-- A tiny stand-in recursion system used to exercise `join_two` without first +/-- 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. -/ @@ -245,6 +246,11 @@ def joinChildProgram : Source.Toplevel := ⟦ assert_eq!(load(store(allowed_digest[0])), allowed_digest[0]); () } + pub fn fake_struct_join(allowed_digest: [G; 8], _out_claim_digest: [G; 8]) { + 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 := @@ -278,6 +284,7 @@ def joinSmokeSuite : IO UInt32 := do 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 @@ -320,7 +327,7 @@ def joinSmokeSuite : IO UInt32 := do let recursionVk := childSystem.vkBytes let allowed := MultiStark.allowedBlob fakeIxvmVk verifyIdx recursionVk - liftIdx childJoinIdx + liftIdx childJoinIdx childStructuralJoinIdx let outputClaimBytes := Ix.Claim.ser outputStatement.claim let pubInput := MultiStark.joinPubInput allowed outputClaimBytes @@ -334,6 +341,7 @@ def joinSmokeSuite : IO UInt32 := do #[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] @@ -358,10 +366,11 @@ def joinSmokeSuite : IO UInt32 := do | .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 leftProof.toBytes rightProof.toBytes recursionVk leftOuterBytes rightOuterBytes - outputClaimBytes allowed preimagesBlob treesBlob + outputClaimBytes allowed preimagesBlob treesBlob emptyPathsBlob let nativeParity : Bool := match honest, honestInterp with | .ok (out, qc), .ok (outI, _, qcI) => out == outI && qc.size == qcI.size && @@ -371,7 +380,95 @@ def joinSmokeSuite : IO UInt32 := do let malformedFraming := compiled.bytecode.executeMultiStarkJoin joinIdx pubInput leftProof.toBytes rightProof.toBytes recursionVk leftOuterBytes rightOuterBytes - outputClaimBytes allowed ⟨#[]⟩ treesBlob + 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 leftProof.toBytes rightProof.toBytes recursionVk + leftOuterBytes rightOuterBytes structuralClaimBytes allowed preimagesBlob + structuralTreesBlob structuralPathsBlob + let structuralInterp := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx + structuralInput leftProof.toBytes rightProof.toBytes 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 leftProof.toBytes rightProof.toBytes 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 leftProof.toBytes rightProof.toBytes 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 leftProof.toBytes rightProof.toBytes 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 leftProof.toBytes rightProof.toBytes 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 leftProof.toBytes rightProof.toBytes 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 @@ -401,6 +498,53 @@ def joinSmokeSuite : IO UInt32 := do 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 + + -- 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 structuralChildProof.toBytes + rightProof.toBytes 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 structuralChildProof.toBytes rightProof.toBytes + 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) @@ -456,20 +600,54 @@ def joinSmokeSuite : IO UInt32 := do match Ix.Cli.CheckCmd.parseIxesManifest duplicate with | .error _ => true | .ok _ => 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 lspecIO (.ofList [("aggregate-first", [ 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 "stand-in lift/join entrypoints survive compiler dedup separately" - (liftIdx != childJoinIdx), + test "stand-in lift/flat/structural entrypoints survive compiler dedup separately" + (liftIdx != childJoinIdx && liftIdx != childStructuralJoinIdx && + childJoinIdx != childStructuralJoinIdx), 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, + 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, diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 0bb9853a4..9f9285a67 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -1019,13 +1019,16 @@ fn build_multi_stark_join_io_buffer( allowed: &[u8], preimages_blob: &[u8], trees_blob: &[u8], + paths_blob: &[u8], ) -> Result { use ixvm_codegen::aiur_multi_stark_runner::{ - JoinAdvice, decode_join_preimages, decode_join_trees, join_io_buffer, + 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, @@ -1034,12 +1037,13 @@ fn build_multi_stark_join_io_buffer( allowed, preimages: &preimages, trees: &trees, + paths: &paths, })) } -/// `Bytecode.Toplevel.executeMultiStarkJoin`: execute `join_two` over raw -/// proof/claim/tree blobs. The native builder expands the compact keyed -/// preimage/tree framing directly into the circuit's six-channel IO buffer. +/// `Bytecode.Toplevel.executeMultiStarkJoin`: execute either join entrypoint over raw +/// proof/claim/tree/path blobs. 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)] @@ -1057,6 +1061,7 @@ extern "C" fn rs_aiur_multi_stark_join_execute( allowed_bytes: LeanByteArray>, preimages_blob: LeanByteArray>, trees_blob: LeanByteArray>, + paths_blob: LeanByteArray>, use_bytecode: bool, ) -> LeanExcept { let toplevel = decode_toplevel(&toplevel); @@ -1071,6 +1076,7 @@ extern "C" fn rs_aiur_multi_stark_join_execute( 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), @@ -1139,7 +1145,7 @@ extern "C" fn rs_aiur_multi_stark_prove( result.into() } -/// `AiurSystem.proveMultiStarkJoin`: prove one valid `join_two` execution +/// `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)] @@ -1157,6 +1163,7 @@ extern "C" fn rs_aiur_multi_stark_join_prove( allowed_bytes: LeanByteArray>, preimages_blob: LeanByteArray>, trees_blob: LeanByteArray>, + paths_blob: LeanByteArray>, use_bytecode: bool, ) -> LeanExcept { let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); @@ -1170,6 +1177,7 @@ extern "C" fn rs_aiur_multi_stark_join_prove( 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), diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index dc4bc3ab5..f73a10d04 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -5161,7 +5161,7 @@ fn aiur_fn_72( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -5342,10 +5342,10 @@ fn aiur_fn_72( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -9652,7 +9652,7 @@ fn aiur_fn_97( 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_231] = { let __args: [G; IN_231] = [__v_87, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_87, __v_107]; 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_108: G = __r_arr[0]; let __ret: [G; OUT_97] = [__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[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)); }; @@ -11351,7 +11351,7 @@ fn aiur_fn_113( 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_226] = { let __args: [G; IN_226] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -12209,7 +12209,7 @@ fn aiur_fn_126( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -12502,7 +12502,7 @@ fn aiur_fn_131( 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_233] = { let __args: [G; IN_233] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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)? } }; @@ -12541,9 +12541,9 @@ fn aiur_fn_131( 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_235] = { let __args: [G; IN_235] = [__v_6]; 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 __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_230] = { let __args: [G; IN_230] = [__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 __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)); @@ -12581,10 +12581,10 @@ fn aiur_fn_132( 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_226] = { let __args: [G; IN_226] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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]; @@ -12637,12 +12637,12 @@ fn aiur_fn_133( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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]; @@ -12690,15 +12690,15 @@ fn aiur_fn_134( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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]; @@ -12748,7 +12748,7 @@ fn aiur_fn_135( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_8, __v_4]; 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 __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() { @@ -12764,12 +12764,12 @@ fn aiur_fn_135( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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]; @@ -12827,7 +12827,7 @@ fn aiur_fn_136( }, 1u64 => { let __v_15: G = G::from_u64(3); - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_1, __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 __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() { @@ -12837,9 +12837,9 @@ fn aiur_fn_136( 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_238] = { let __args: [G; IN_238] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_238] = { let __args: [G; IN_238] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -12848,7 +12848,7 @@ fn aiur_fn_136( 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_233] = { let __args: [G; IN_233] = [__v_8, __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 __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_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]; @@ -12898,7 +12898,7 @@ fn aiur_fn_137( }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -12987,7 +12987,7 @@ fn aiur_fn_139( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2, __v_4]; 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 __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() { @@ -13004,7 +13004,7 @@ fn aiur_fn_139( }, 1u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -13416,7 +13416,7 @@ fn aiur_fn_143( 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_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 __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) { @@ -13451,7 +13451,7 @@ fn aiur_fn_143( 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_228] = { let __args: [G; IN_228] = [__v_11, __v_26]; 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 __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() { @@ -13566,7 +13566,7 @@ fn aiur_fn_143( 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_230] = { let __args: [G; IN_230] = [__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 __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) { @@ -13805,7 +13805,7 @@ fn aiur_fn_144( 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_228] = { let __args: [G; IN_228] = [__v_1, __v_28]; 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 __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() { @@ -13814,7 +13814,7 @@ fn aiur_fn_144( 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_228] = { let __args: [G; IN_228] = [__v_1, __v_33]; 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 __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() { @@ -13823,7 +13823,7 @@ fn aiur_fn_144( 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_228] = { let __args: [G; IN_228] = [__v_1, __v_38]; 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 __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() { @@ -13851,10 +13851,10 @@ fn aiur_fn_144( 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_228] = { let __args: [G; IN_228] = [__v_23, __v_54]; 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 __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_229] = { let __args: [G; IN_229] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -13862,7 +13862,7 @@ fn aiur_fn_144( 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_230] = { let __args: [G; IN_230] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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)? } }; @@ -13874,7 +13874,7 @@ fn aiur_fn_144( 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_238] = { let __args: [G; IN_238] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -13888,7 +13888,7 @@ fn aiur_fn_144( 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_238] = { let __args: [G; IN_238] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -13902,7 +13902,7 @@ fn aiur_fn_144( 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_238] = { let __args: [G; IN_238] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -14063,7 +14063,7 @@ fn aiur_fn_146( let __v_30: G = inp[30]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -14089,7 +14089,7 @@ fn aiur_fn_146( 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_232] = { let __args: [G; IN_232] = [__v_0, __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 __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); @@ -14163,7 +14163,7 @@ fn aiur_fn_146( 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_232] = { let __args: [G; IN_232] = [__v_104, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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]; @@ -14171,7 +14171,7 @@ fn aiur_fn_146( 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_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 __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)); @@ -14179,7 +14179,7 @@ fn aiur_fn_146( 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_230] = { let __args: [G; IN_230] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -14187,7 +14187,7 @@ fn aiur_fn_146( 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_230] = { let __args: [G; IN_230] = [__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 __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) { @@ -15066,7 +15066,7 @@ fn aiur_fn_158( 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_232] = { let __args: [G; IN_232] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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)); }; @@ -15091,7 +15091,7 @@ fn aiur_fn_159( 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_232] = { let __args: [G; IN_232] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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)); }; @@ -15336,7 +15336,7 @@ fn aiur_fn_163( 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_232] = { let __args: [G; IN_232] = [__v_75, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -15367,7 +15367,7 @@ fn aiur_fn_163( 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_232] = { let __args: [G; IN_232] = [__v_102, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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]; @@ -15376,7 +15376,7 @@ fn aiur_fn_163( 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_232] = { let __args: [G; IN_232] = [__v_110, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -15908,24 +15908,24 @@ fn aiur_fn_169( let __v_22: G = inp[22]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__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 __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_238] = { let __args: [G; IN_238] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_238] = { let __args: [G; IN_238] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_238] = { let __args: [G; IN_238] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 }); @@ -16090,7 +16090,7 @@ fn aiur_fn_173( let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0, __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 __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]; @@ -16107,7 +16107,7 @@ fn aiur_fn_173( let __v_20: G = (__v_16 + __v_19); match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4, __v_18]; 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 __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_173] = [__v_21, __v_22]; @@ -16115,7 +16115,7 @@ fn aiur_fn_173( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_18]; 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 __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_173] = [__v_21, __v_22]; @@ -16123,7 +16123,7 @@ fn aiur_fn_173( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2, __v_18]; 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 __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_173] = [__v_21, __v_22]; @@ -16131,7 +16131,7 @@ fn aiur_fn_173( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_3, __v_18]; 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 __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_173] = [__v_21, __v_22]; @@ -16139,7 +16139,7 @@ fn aiur_fn_173( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_6, __v_18]; 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 __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_173] = [__v_21, __v_22]; @@ -16147,7 +16147,7 @@ fn aiur_fn_173( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_7, __v_18]; 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 __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_173] = [__v_21, __v_22]; @@ -16157,7 +16157,7 @@ fn aiur_fn_173( } }, 2u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_8, __v_16]; 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 __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_173] = [__v_19, __v_20]; @@ -16559,23 +16559,23 @@ fn aiur_fn_177( match __v_88.as_canonical_u64() { 0u64 => { let __v_89: G = (__v_7 + __v_7); - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_35, __v_89]; 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 __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_228] = { let __args: [G; IN_228] = [__v_35, __v_94]; 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 __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_228] = { let __args: [G; IN_228] = [__v_36, __v_97]; 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 __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_228] = { let __args: [G; IN_228] = [__v_36, __v_102]; 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 __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); @@ -16609,25 +16609,25 @@ fn aiur_fn_177( match __v_90.as_canonical_u64() { 0u64 => { let __v_91: G = (__v_7 + __v_7); - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_35, __v_91]; 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 __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_228] = { let __args: [G; IN_228] = [__v_35, __v_96]; 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 __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_228] = { let __args: [G; IN_228] = [__v_35, __v_101]; 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 __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_228] = { let __args: [G; IN_228] = [__v_35, __v_106]; 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 __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); @@ -16790,11 +16790,11 @@ fn aiur_fn_178( match __v_78.as_canonical_u64() { 1u64 => { let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_9, __v_82]; 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 __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_228] = { let __args: [G; IN_228] = [__v_8, __v_85]; 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 __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); @@ -16805,11 +16805,11 @@ fn aiur_fn_178( 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_228] = { let __args: [G; IN_228] = [__v_9, __v_94]; 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 __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_228] = { let __args: [G; IN_228] = [__v_8, __v_97]; 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 __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); @@ -16825,7 +16825,7 @@ fn aiur_fn_178( }, 0u64 => { let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -17132,13 +17132,13 @@ fn aiur_fn_182( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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)); }; @@ -17205,30 +17205,30 @@ fn aiur_fn_183( 0u64 => { match __v_21.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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_228] = { let __args: [G; IN_228] = [__v_3, __v_9]; 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 __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_226] = { let __args: [G; IN_226] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_37, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_228] = { let __args: [G; IN_228] = [__v_1, __v_9]; 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 __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() { @@ -17253,13 +17253,13 @@ fn aiur_fn_183( break '__mc_0 [__v_46, __v_49]; }, 1u64 => { - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; }, @@ -17498,11 +17498,11 @@ fn aiur_fn_183( 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_228] = { let __args: [G; IN_228] = [__v_41, __v_230]; 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 __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_228] = { let __args: [G; IN_228] = [__v_39, __v_233]; 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 __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); @@ -17513,11 +17513,11 @@ fn aiur_fn_183( 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_228] = { let __args: [G; IN_228] = [__v_41, __v_242]; 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 __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_228] = { let __args: [G; IN_228] = [__v_39, __v_245]; 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 __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); @@ -17531,7 +17531,7 @@ fn aiur_fn_183( }, 0u64 => { let __v_230: G = G::from_u64(0); - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -17554,10 +17554,10 @@ fn aiur_fn_183( }; let __v_230: G = __mc_out___mc_1[0]; let __v_231: G = __mc_out___mc_1[1]; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_226] = { let __args: [G; IN_226] = [__v_232, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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]; @@ -17583,7 +17583,7 @@ fn aiur_fn_183( 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_230] = { let __args: [G; IN_230] = [__v_235]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -17924,7 +17924,7 @@ fn aiur_fn_186( 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_232] = { let __args: [G; IN_232] = [__v_106, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -17955,7 +17955,7 @@ fn aiur_fn_186( 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_232] = { let __args: [G; IN_232] = [__v_133, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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]; @@ -17964,7 +17964,7 @@ fn aiur_fn_186( 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_232] = { let __args: [G; IN_232] = [__v_141, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -18188,11 +18188,11 @@ fn aiur_fn_186( 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_237] = { let __args: [G; IN_237] = [__v_37]; 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 __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_238] = { let __args: [G; IN_238] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -18218,7 +18218,7 @@ fn aiur_fn_186( 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_232] = { let __args: [G; IN_232] = [__v_188, __v_372]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -18292,7 +18292,7 @@ fn aiur_fn_186( 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_232] = { let __args: [G; IN_232] = [__v_438, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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]; @@ -18306,9 +18306,9 @@ fn aiur_fn_186( 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_238] = { let __args: [G; IN_238] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_237] = { let __args: [G; IN_237] = [__v_8]; 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 __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)); @@ -18316,9 +18316,9 @@ fn aiur_fn_186( 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_237] = { let __args: [G; IN_237] = [__v_37]; 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 __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_230] = { let __args: [G; IN_230] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -18326,7 +18326,7 @@ fn aiur_fn_186( 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_235] = { let __args: [G; IN_235] = [__v_19]; 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 __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)); @@ -18334,7 +18334,7 @@ fn aiur_fn_186( 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_230] = { let __args: [G; IN_230] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -18342,7 +18342,7 @@ fn aiur_fn_186( 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_230] = { let __args: [G; IN_230] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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) { @@ -19880,7 +19880,7 @@ fn aiur_fn_202( 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_232] = { let __args: [G; IN_232] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); }; @@ -20178,7 +20178,7 @@ fn aiur_fn_207( 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_227] = { let __args: [G; IN_227] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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) { @@ -20615,15 +20615,284 @@ fn aiur_fn_213( }) } -const INPUT_SIZE_214: usize = 1; -const IN_214: usize = 1; -const OUT_214: usize = 3; +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)? } }; @@ -20633,8 +20902,8 @@ fn aiur_fn_214( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_214] = [__v_3, __v_4, __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)); }; + 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 => { @@ -20642,8 +20911,8 @@ fn aiur_fn_214( 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_214] = [__v_5, __v_3, __v_4]; - if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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); }, _ => { @@ -20653,15 +20922,15 @@ fn aiur_fn_214( }) } -const INPUT_SIZE_215: usize = 1; -const IN_215: usize = 1; -const OUT_215: usize = 3; -fn aiur_fn_215( - inp: [G; IN_215], +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_215], ExecError> { +) -> 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)? } }; @@ -20670,7 +20939,7 @@ fn aiur_fn_215( 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_214] = { let __args: [G; IN_214] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -20693,21 +20962,21 @@ fn aiur_fn_215( 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_215] = [__v_3, __v_5, __v_6]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_216: usize = 8; -const IN_216: usize = 8; -const OUT_216: usize = 1; -fn aiur_fn_216( - inp: [G; IN_216], +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_216], ExecError> { +) -> 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]; @@ -20905,25 +21174,25 @@ fn aiur_fn_216( 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_216] = [__v_12]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_217: usize = 2; -const IN_217: usize = 2; -const OUT_217: usize = 1; -fn aiur_fn_217( - inp: [G; IN_217], +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_217], ExecError> { +) -> 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_239] = { let __args: [G; IN_239] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -20953,69 +21222,69 @@ fn aiur_fn_217( 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_217] = [__v_30]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_218: usize = 2; -const IN_218: usize = 2; -const OUT_218: usize = 8; -fn aiur_fn_218( - inp: [G; IN_218], +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_218], ExecError> { +) -> 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_217] = { let __args: [G; IN_217] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_0, __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 __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_217] = { let __args: [G; IN_217] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_0, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_218] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_219: usize = 16; -const IN_219: usize = 16; -const OUT_219: usize = 0; -fn aiur_fn_219( - inp: [G; IN_219], +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_219], ExecError> { +) -> 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]; @@ -21057,21 +21326,21 @@ fn aiur_fn_219( 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_219] = []; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_220: usize = 1; -const IN_220: usize = 1; -const OUT_220: usize = 1; -fn aiur_fn_220( - inp: [G; IN_220], +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_220], ExecError> { +) -> 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 }; @@ -21095,8 +21364,8 @@ fn aiur_fn_220( 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_220] = [__v_2]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -21106,15 +21375,15 @@ fn aiur_fn_220( }) } -const INPUT_SIZE_221: usize = 13; -const IN_221: usize = 13; -const OUT_221: usize = 1; -fn aiur_fn_221( - inp: [G; IN_221], +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_221], ExecError> { +) -> 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]; @@ -21213,7 +21482,7 @@ fn aiur_fn_221( let __v_70: G = __r_arr[1]; match __v_18.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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() { _ => { @@ -21324,7 +21593,7 @@ fn aiur_fn_221( 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_232] = { let __args: [G; IN_232] = [__v_141, __v_147]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -21355,7 +21624,7 @@ fn aiur_fn_221( 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_232] = { let __args: [G; IN_232] = [__v_168, __v_174]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -21364,7 +21633,7 @@ fn aiur_fn_221( 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_232] = { let __args: [G; IN_232] = [__v_176, __v_180]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -21588,11 +21857,11 @@ fn aiur_fn_221( 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_237] = { let __args: [G; IN_237] = [__v_72]; 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 __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_238] = { let __args: [G; IN_238] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -21618,7 +21887,7 @@ fn aiur_fn_221( 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_232] = { let __args: [G; IN_232] = [__v_223, __v_407]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -21692,7 +21961,7 @@ fn aiur_fn_221( 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_232] = { let __args: [G; IN_232] = [__v_473, __v_477]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -21724,17 +21993,17 @@ fn aiur_fn_221( 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_238] = { let __args: [G; IN_238] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_238] = { let __args: [G; IN_238] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_238] = { let __args: [G; IN_238] = [__v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 }); @@ -21756,9 +22025,9 @@ fn aiur_fn_221( 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_238] = { let __args: [G; IN_238] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_237] = { let __args: [G; IN_237] = [__v_8]; 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 __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)); @@ -21766,9 +22035,9 @@ fn aiur_fn_221( 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_237] = { let __args: [G; IN_237] = [__v_72]; 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 __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_230] = { let __args: [G; IN_230] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -21776,7 +22045,7 @@ fn aiur_fn_221( 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_235] = { let __args: [G; IN_235] = [__v_36]; 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 __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)); @@ -21784,7 +22053,7 @@ fn aiur_fn_221( 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_230] = { let __args: [G; IN_230] = [__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 __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)); @@ -21792,7 +22061,7 @@ fn aiur_fn_221( 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_230] = { let __args: [G; IN_230] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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) { @@ -21810,8 +22079,8 @@ fn aiur_fn_221( 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_221] = [__v_69]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, } @@ -21828,20 +22097,20 @@ fn aiur_fn_221( }) } -const INPUT_SIZE_222: usize = 2; -const IN_222: usize = 2; -const OUT_222: usize = 3; -fn aiur_fn_222( - inp: [G; IN_222], +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_222], ExecError> { +) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(10); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -21850,7 +22119,7 @@ fn aiur_fn_222( 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_216] = { let __args: [G; IN_216] = [__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[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -21858,10 +22127,10 @@ fn aiur_fn_222( 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_220] = { let __args: [G; IN_220] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_218] = { let __args: [G; IN_218] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -21885,46 +22154,46 @@ fn aiur_fn_222( 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_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 __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_217] = { let __args: [G; IN_217] = [__v_16, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_16, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_216] = { let __args: [G; IN_216] = [__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[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_215] = { let __args: [G; IN_215] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_222] = [__v_39, __v_40, __v_41]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_223: usize = 20; -const IN_223: usize = 20; -const OUT_223: usize = 3; -fn aiur_fn_223( - inp: [G; IN_223], +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_223], ExecError> { +) -> 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]; @@ -21946,95 +22215,107 @@ fn aiur_fn_223( let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0]; 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(1); - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_20, __v_21]; 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_22: G = __r_arr[0]; - 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_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 __v_24: G = G::from_u64(18); - if (__v_23 != __v_24) { - return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("join: recursive child claim must contain 16 public inputs".to_string()) }); + 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_25: G = G::from_u64(0); - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_20, __v_25]; 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_26: G = __r_arr[0]; - let __v_27: G = G::from_u64(0); - if (__v_26 != __v_27) { - return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("join: recursive child has the wrong claim channel".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_28: G = (__v_22 - __v_18); - let __v_29: G = G::from_bool((__v_28 == G::ZERO)); - match __v_29.as_canonical_u64() { + 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_30: G = G::from_u64(2); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_20, __v_30]; 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_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 __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_20, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; - let __v_39: G = __r_arr[0]; - let __v_40: G = __r_arr[1]; - let __v_41: G = __r_arr[2]; - let __ret: [G; OUT_223] = [__v_39, __v_40, __v_41]; - 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); - }, - _ => { - let __v_30: G = G::from_u64(2); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_20, __v_30]; 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_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 __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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[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_39: G = G::from_u64(10); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_20, __v_39]; 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_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 __v_43: G = __r_arr[3]; - let __v_44: G = __r_arr[4]; - let __v_45: G = __r_arr[5]; - let __v_46: G = __r_arr[6]; - let __v_47: G = __r_arr[7]; - if (__v_22 != __v_19) { - return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("join: child is neither lift nor join".to_string()) }); - } - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_48: G = __r_arr[0]; - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_48]; 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_49: G = __r_arr[0]; - let __v_50: G = __r_arr[1]; - let __v_51: G = __r_arr[2]; - let __ret: [G; OUT_223] = [__v_49, __v_50, __v_51]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_224: usize = 16; -const IN_224: usize = 16; -const OUT_224: usize = 0; -fn aiur_fn_224( - inp: [G; IN_224], +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_224], 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]; @@ -22223,701 +22504,1645 @@ fn aiur_fn_224( 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_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 __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 __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 __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 __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 __v_167: G = __r_arr[2]; - let __v_168: G = __r_arr[3]; - let __v_169: G = __r_arr[4]; - let __v_170: G = __r_arr[5]; - let __v_171: G = __r_arr[6]; - let __v_172: G = __r_arr[7]; - let __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 __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_174: G = __r_arr[0]; + 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_175: G = __r_arr[0]; - let __v_176: G = G::from_u64(1); - let __v_177: G = G::from_u64(0); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_177]; let __info = io_buffer.get_info(__v_176, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_178: G = __io_pair.0; - let __v_179: G = __io_pair.1; - let __v_180: G = G::from_u64(1); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_180, __v_178, __v_179]; 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_181: G = __r_arr[0]; - 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(127); - let __v_199: G = G::from_u64(82); - let __v_200: G = G::from_u64(14); - let __v_201: G = G::from_u64(81); - let __v_202: G = G::from_u64(140); - let __v_203: G = G::from_u64(104); - let __v_204: G = G::from_u64(5); - let __v_205: G = G::from_u64(155); - let __v_206: G = G::from_u64(171); - let __v_207: G = G::from_u64(217); - let __v_208: G = G::from_u64(131); - let __v_209: G = G::from_u64(31); - let __v_210: G = G::from_u64(25); - let __v_211: G = G::from_u64(205); - let __v_212: G = G::from_u64(224); - let __v_213: G = G::from_u64(91); - let __v_214: G = G::from_u64(1); - let __v_215: G = G::from_u64(1); - let __v_216: G = { let __values: [G; 3] = [__v_214, __v_215, __v_215]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0); - let __v_218: G = G::from_u64(0); - let __v_219: G = G::from_u64(0); - let __v_220: G = G::from_u64(0); - let __v_221: G = G::from_u64(0); - let __v_222: G = G::from_u64(0); - let __v_223: G = G::from_u64(0); - let __v_224: G = G::from_u64(0); - let __v_225: G = G::from_u64(0); - let __v_226: G = G::from_u64(0); - let __v_227: G = { let __values: [G; 8] = [__v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226]; 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_228: G = { let __values: [G; 32] = [__v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1); - let __v_230: G = G::from_u64(1); - let __v_231: G = { let __values: [G; 34] = [__v_229, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230, __v_230]; 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_181, __v_216, __v_217, __v_218, __v_227, __v_228, __v_231]; 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_232: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_232]; 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_233: G = __r_arr[0]; - let __v_234: G = __r_arr[1]; - let __v_235: G = __r_arr[2]; - let __v_236: G = __r_arr[3]; - let __v_237: G = __r_arr[4]; - let __v_238: G = __r_arr[5]; - let __v_239: G = __r_arr[6]; - let __v_240: G = __r_arr[7]; - let __v_241: G = __r_arr[8]; - let __v_242: G = __r_arr[9]; - let __v_243: G = __r_arr[10]; - let __v_244: G = __r_arr[11]; - let __v_245: G = __r_arr[12]; - let __v_246: G = __r_arr[13]; - let __v_247: G = __r_arr[14]; - let __v_248: G = __r_arr[15]; - let __v_249: G = __r_arr[16]; - let __v_250: G = __r_arr[17]; - let __v_251: G = __r_arr[18]; - let __v_252: G = __r_arr[19]; - let __v_253: G = __r_arr[20]; - let __v_254: G = __r_arr[21]; - let __v_255: G = __r_arr[22]; - let __v_256: G = __r_arr[23]; - let __v_257: G = __r_arr[24]; - let __v_258: G = __r_arr[25]; - let __v_259: G = __r_arr[26]; - let __v_260: G = __r_arr[27]; - let __v_261: G = __r_arr[28]; - let __v_262: G = __r_arr[29]; - let __v_263: G = __r_arr[30]; - let __v_264: G = __r_arr[31]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_181]; 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_265: G = __r_arr[0]; - let __v_266: G = __r_arr[1]; - let __v_267: G = __r_arr[2]; - let __v_268: G = __r_arr[3]; - let __v_269: G = __r_arr[4]; - let __v_270: G = __r_arr[5]; - let __v_271: G = __r_arr[6]; - let __v_272: G = __r_arr[7]; - let __v_273: G = __r_arr[8]; - let __v_274: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_274]; 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_275: G = __r_arr[0]; - let __v_276: G = __r_arr[1]; - let __v_277: G = __r_arr[2]; - let __v_278: G = __r_arr[3]; - let __v_279: G = __r_arr[4]; - let __v_280: G = __r_arr[5]; - let __v_281: G = __r_arr[6]; - let __v_282: G = __r_arr[7]; - let __v_283: G = __r_arr[8]; - let __v_284: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_284]; 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_285: G = __r_arr[0]; - let __v_286: G = __r_arr[1]; - let __v_287: G = __r_arr[2]; - let __v_288: G = __r_arr[3]; - let __v_289: G = __r_arr[4]; - let __v_290: G = __r_arr[5]; - let __v_291: G = __r_arr[6]; - let __v_292: G = __r_arr[7]; - let __v_293: G = __r_arr[8]; - let __v_294: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_294]; 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_295: G = __r_arr[0]; - let __v_296: G = __r_arr[1]; - let __v_297: G = __r_arr[2]; - let __v_298: G = __r_arr[3]; - let __v_299: G = __r_arr[4]; - let __v_300: G = __r_arr[5]; - let __v_301: G = __r_arr[6]; - let __v_302: G = __r_arr[7]; - let __v_303: G = __r_arr[8]; - let __v_304: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_304]; 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_305: G = __r_arr[0]; - let __v_306: G = __r_arr[1]; - let __v_307: G = __r_arr[2]; - let __v_308: G = __r_arr[3]; - let __v_309: G = __r_arr[4]; - let __v_310: G = __r_arr[5]; - let __v_311: G = __r_arr[6]; - let __v_312: G = __r_arr[7]; - let __v_313: G = __r_arr[8]; - let __v_314: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_314]; 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_315: G = __r_arr[0]; - let __v_316: G = __r_arr[1]; - let __v_317: G = __r_arr[2]; - let __v_318: G = __r_arr[3]; - let __v_319: G = __r_arr[4]; - let __v_320: G = __r_arr[5]; - let __v_321: G = __r_arr[6]; - let __v_322: G = __r_arr[7]; - let __v_323: G = __r_arr[8]; - let __v_324: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_324]; 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_325: G = __r_arr[0]; - let __v_326: G = __r_arr[1]; - let __v_327: G = __r_arr[2]; - let __v_328: G = __r_arr[3]; - let __v_329: G = __r_arr[4]; - let __v_330: G = __r_arr[5]; - let __v_331: G = __r_arr[6]; - let __v_332: G = __r_arr[7]; - let __v_333: G = __r_arr[8]; - let __v_334: G = __r_arr[9]; - let __v_335: G = G::from_u64(0); - let __v_336: G = G::from_u64(0); - let __v_337: G = G::from_u64(0); - let __v_338: G = G::from_u64(0); - let __v_339: G = G::from_u64(0); - let __v_340: G = G::from_u64(0); - let __v_341: G = G::from_u64(0); - let __v_342: G = G::from_u64(1); - let __v_343: G = G::from_u64(1); - let __v_344: G = { let __values: [G; 10] = [__v_342, __v_343, __v_343, __v_343, __v_343, __v_343, __v_343, __v_343, __v_343, __v_343]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_345: G = { let __values: [G; 10] = [__v_341, __v_326, __v_327, __v_328, __v_329, __v_330, __v_331, __v_332, __v_333, __v_344]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_346: G = { let __values: [G; 10] = [__v_340, __v_316, __v_317, __v_318, __v_319, __v_320, __v_321, __v_322, __v_323, __v_345]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_347: G = { let __values: [G; 10] = [__v_339, __v_306, __v_307, __v_308, __v_309, __v_310, __v_311, __v_312, __v_313, __v_346]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_348: G = { let __values: [G; 10] = [__v_338, __v_296, __v_297, __v_298, __v_299, __v_300, __v_301, __v_302, __v_303, __v_347]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_349: G = { let __values: [G; 10] = [__v_337, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_348]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_350: G = { let __values: [G; 10] = [__v_336, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_349]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_351: G = { let __values: [G; 10] = [__v_335, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_350]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_334]; 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_352: G = __r_arr[0]; - let __v_353: G = __r_arr[1]; - let __v_354: G = __r_arr[2]; - let __v_355: G = __r_arr[3]; - let __v_356: G = __r_arr[4]; - let __v_357: G = __r_arr[5]; - let __v_358: G = __r_arr[6]; - let __v_359: G = __r_arr[7]; - let __v_360: G = __r_arr[8]; - let __v_361: G = __r_arr[9]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_361, __v_352]; 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_362: G = __r_arr[0]; - let __v_363: G = __r_arr[1]; - let __v_364: G = __r_arr[2]; - let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_364]; 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_365: G = __r_arr[0]; - let __v_366: G = __r_arr[1]; - let __v_367: G = __r_arr[2]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_367, __v_352]; 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_368: G = __r_arr[0]; - let __v_369: G = __r_arr[1]; - let __v_370: G = G::from_u64(0); - let __v_371: G = { let __values: [G; 10] = [__v_370, __v_353, __v_354, __v_355, __v_356, __v_357, __v_358, __v_359, __v_360, __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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_351, __v_371]; 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_372: G = __r_arr[0]; - let __v_373: G = G::from_u64(0); - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_265, __v_275, __v_285, __v_295, __v_305, __v_315, __v_325, __v_372, __v_362, __v_365, __v_366, __v_368, __v_373]; 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_374: G = __r_arr[0]; - let __v_375: G = G::from_u64(1); - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_265, __v_275, __v_285, __v_295, __v_305, __v_315, __v_325, __v_372, __v_362, __v_365, __v_366, __v_368, __v_375]; 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_376: G = __r_arr[0]; - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_374, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_173, __v_174, __v_175]; 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_377: G = __r_arr[0]; - let __v_378: G = __r_arr[1]; - let __v_379: G = __r_arr[2]; - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_376, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_173, __v_174, __v_175]; 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_380: G = __r_arr[0]; - let __v_381: G = __r_arr[1]; - let __v_382: G = __r_arr[2]; - let __v_383: G = G::from_u64(2); - let __v_384: G = G::from_u64(2); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_384]; let __info = io_buffer.get_info(__v_383, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_385: G = __io_pair.0; - let __v_386: G = __io_pair.1; - let __v_387: G = G::from_u64(2); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_387, __v_385, __v_386]; 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_388: G = __r_arr[0]; - let __v_389: G = G::from_u64(103); - let __v_390: G = G::from_u64(230); - let __v_391: G = G::from_u64(9); - let __v_392: G = G::from_u64(106); - let __v_393: G = G::from_u64(133); - let __v_394: G = G::from_u64(174); - let __v_395: G = G::from_u64(103); - let __v_396: G = G::from_u64(187); - let __v_397: G = G::from_u64(114); - let __v_398: G = G::from_u64(243); - let __v_399: G = G::from_u64(110); - let __v_400: G = G::from_u64(60); - let __v_401: G = G::from_u64(58); - let __v_402: G = G::from_u64(245); - let __v_403: G = G::from_u64(79); - let __v_404: G = G::from_u64(165); - let __v_405: G = G::from_u64(127); - let __v_406: G = G::from_u64(82); - let __v_407: G = G::from_u64(14); - let __v_408: G = G::from_u64(81); - let __v_409: G = G::from_u64(140); - let __v_410: G = G::from_u64(104); - let __v_411: G = G::from_u64(5); - let __v_412: G = G::from_u64(155); - let __v_413: G = G::from_u64(171); - let __v_414: G = G::from_u64(217); - let __v_415: G = G::from_u64(131); - let __v_416: G = G::from_u64(31); - let __v_417: G = G::from_u64(25); - let __v_418: G = G::from_u64(205); - let __v_419: G = G::from_u64(224); - let __v_420: G = G::from_u64(91); - let __v_421: G = G::from_u64(1); - let __v_422: G = G::from_u64(1); - let __v_423: G = { let __values: [G; 3] = [__v_421, __v_422, __v_422]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_424: G = G::from_u64(0); - let __v_425: G = G::from_u64(0); - let __v_426: G = G::from_u64(0); - let __v_427: G = G::from_u64(0); - let __v_428: G = G::from_u64(0); - let __v_429: G = G::from_u64(0); - let __v_430: G = G::from_u64(0); - let __v_431: G = G::from_u64(0); - let __v_432: G = G::from_u64(0); - let __v_433: G = G::from_u64(0); - let __v_434: G = { let __values: [G; 8] = [__v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433]; 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_435: G = { let __values: [G; 32] = [__v_389, __v_390, __v_391, __v_392, __v_393, __v_394, __v_395, __v_396, __v_397, __v_398, __v_399, __v_400, __v_401, __v_402, __v_403, __v_404, __v_405, __v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1); - let __v_437: G = G::from_u64(1); - let __v_438: G = { let __values: [G; 34] = [__v_436, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437, __v_437]; 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_388, __v_423, __v_424, __v_425, __v_434, __v_435, __v_438]; 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_439: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_439]; 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_440: G = __r_arr[0]; - let __v_441: G = __r_arr[1]; - let __v_442: G = __r_arr[2]; - let __v_443: G = __r_arr[3]; - let __v_444: G = __r_arr[4]; - let __v_445: G = __r_arr[5]; - let __v_446: G = __r_arr[6]; - let __v_447: G = __r_arr[7]; - let __v_448: G = __r_arr[8]; - let __v_449: G = __r_arr[9]; - let __v_450: G = __r_arr[10]; - let __v_451: G = __r_arr[11]; - let __v_452: G = __r_arr[12]; - let __v_453: G = __r_arr[13]; - let __v_454: G = __r_arr[14]; - let __v_455: G = __r_arr[15]; - let __v_456: G = __r_arr[16]; - let __v_457: G = __r_arr[17]; - let __v_458: G = __r_arr[18]; - let __v_459: G = __r_arr[19]; - let __v_460: G = __r_arr[20]; - let __v_461: G = __r_arr[21]; - let __v_462: G = __r_arr[22]; - let __v_463: G = __r_arr[23]; - let __v_464: G = __r_arr[24]; - let __v_465: G = __r_arr[25]; - let __v_466: G = __r_arr[26]; - let __v_467: G = __r_arr[27]; - let __v_468: G = __r_arr[28]; - let __v_469: G = __r_arr[29]; - let __v_470: G = __r_arr[30]; - let __v_471: G = __r_arr[31]; - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_388]; 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_472: G = __r_arr[0]; - let __v_473: G = __r_arr[1]; - let __v_474: G = __r_arr[2]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_377]; 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_475: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_380]; 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_476: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_378, __v_379]; 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_477: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_381, __v_382]; 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_478: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_472]; 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_479: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_473, __v_474]; 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_480: G = __r_arr[0]; - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_475, __v_476, __v_479]; 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_477, __v_478, __v_479, __v_480]; 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_481: G = G::from_u64(256); - let __v_482: G = (__v_481 * __v_74); - let __v_483: G = G::from_u64(65536); - let __v_484: G = (__v_483 * __v_75); - let __v_485: G = G::from_u64(16777216); - let __v_486: G = (__v_485 * __v_76); - let __v_487: G = (__v_484 + __v_486); - let __v_488: G = (__v_482 + __v_487); - let __v_489: G = (__v_73 + __v_488); - let __v_490: G = G::from_u64(256); - let __v_491: G = (__v_490 * __v_78); - let __v_492: G = G::from_u64(65536); - let __v_493: G = (__v_492 * __v_79); - let __v_494: G = G::from_u64(16777216); - let __v_495: G = (__v_494 * __v_80); - let __v_496: G = (__v_493 + __v_495); - let __v_497: G = (__v_491 + __v_496); - let __v_498: G = (__v_77 + __v_497); + 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(0); + let __v_388: G = { let __values: [G; 10] = [__v_387, __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 __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_368, __v_388]; 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_389: G = __r_arr[0]; + let __v_390: 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_389, __v_379, __v_382, __v_383, __v_385, __v_390]; 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_391: G = __r_arr[0]; + let __v_392: 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_389, __v_379, __v_382, __v_383, __v_385, __v_392]; 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_393: G = __r_arr[0]; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_391, __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_394: G = __r_arr[0]; + let __v_395: G = __r_arr[1]; + let __v_396: G = __r_arr[2]; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_393, __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_397: G = __r_arr[0]; + let __v_398: G = __r_arr[1]; + let __v_399: G = __r_arr[2]; + let __v_400: G = G::from_u64(2); + let __v_401: G = G::from_u64(2); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_401]; let __info = io_buffer.get_info(__v_400, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_402: G = __io_pair.0; + let __v_403: G = __io_pair.1; + let __v_404: G = G::from_u64(2); + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_404, __v_402, __v_403]; 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_405: G = __r_arr[0]; + let __v_406: G = G::from_u64(103); + let __v_407: G = G::from_u64(230); + let __v_408: G = G::from_u64(9); + let __v_409: G = G::from_u64(106); + let __v_410: G = G::from_u64(133); + let __v_411: G = G::from_u64(174); + let __v_412: G = G::from_u64(103); + let __v_413: G = G::from_u64(187); + let __v_414: G = G::from_u64(114); + let __v_415: G = G::from_u64(243); + let __v_416: G = G::from_u64(110); + let __v_417: G = G::from_u64(60); + let __v_418: G = G::from_u64(58); + let __v_419: G = G::from_u64(245); + let __v_420: G = G::from_u64(79); + let __v_421: G = G::from_u64(165); + let __v_422: G = G::from_u64(127); + let __v_423: G = G::from_u64(82); + let __v_424: G = G::from_u64(14); + let __v_425: G = G::from_u64(81); + let __v_426: G = G::from_u64(140); + let __v_427: G = G::from_u64(104); + let __v_428: G = G::from_u64(5); + let __v_429: G = G::from_u64(155); + let __v_430: G = G::from_u64(171); + let __v_431: G = G::from_u64(217); + let __v_432: G = G::from_u64(131); + let __v_433: G = G::from_u64(31); + let __v_434: G = G::from_u64(25); + let __v_435: G = G::from_u64(205); + let __v_436: G = G::from_u64(224); + let __v_437: G = G::from_u64(91); + let __v_438: G = G::from_u64(1); + let __v_439: G = G::from_u64(1); + let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_441: G = G::from_u64(0); + let __v_442: G = G::from_u64(0); + let __v_443: G = G::from_u64(0); + let __v_444: G = G::from_u64(0); + let __v_445: G = G::from_u64(0); + let __v_446: G = G::from_u64(0); + let __v_447: G = G::from_u64(0); + let __v_448: G = G::from_u64(0); + let __v_449: G = G::from_u64(0); + let __v_450: G = G::from_u64(0); + let __v_451: G = { let __values: [G; 8] = [__v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_449, __v_450]; 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_452: G = { let __values: [G; 32] = [__v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1); + let __v_454: G = G::from_u64(1); + let __v_455: G = { let __values: [G; 34] = [__v_453, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454]; 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_405, __v_440, __v_441, __v_442, __v_451, __v_452, __v_455]; 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_456: G = __r_arr[0]; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_456]; 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_457: G = __r_arr[0]; + let __v_458: G = __r_arr[1]; + let __v_459: G = __r_arr[2]; + let __v_460: G = __r_arr[3]; + let __v_461: G = __r_arr[4]; + let __v_462: G = __r_arr[5]; + let __v_463: G = __r_arr[6]; + let __v_464: G = __r_arr[7]; + let __v_465: G = __r_arr[8]; + let __v_466: G = __r_arr[9]; + let __v_467: G = __r_arr[10]; + let __v_468: G = __r_arr[11]; + let __v_469: G = __r_arr[12]; + let __v_470: G = __r_arr[13]; + let __v_471: G = __r_arr[14]; + let __v_472: G = __r_arr[15]; + let __v_473: G = __r_arr[16]; + let __v_474: G = __r_arr[17]; + let __v_475: G = __r_arr[18]; + let __v_476: G = __r_arr[19]; + let __v_477: G = __r_arr[20]; + let __v_478: G = __r_arr[21]; + let __v_479: G = __r_arr[22]; + let __v_480: G = __r_arr[23]; + let __v_481: G = __r_arr[24]; + let __v_482: G = __r_arr[25]; + let __v_483: G = __r_arr[26]; + let __v_484: G = __r_arr[27]; + let __v_485: G = __r_arr[28]; + let __v_486: G = __r_arr[29]; + let __v_487: G = __r_arr[30]; + let __v_488: G = __r_arr[31]; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_405]; 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_489: G = __r_arr[0]; + let __v_490: G = __r_arr[1]; + let __v_491: G = __r_arr[2]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_394]; 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_492: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_397]; 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_493: G = __r_arr[0]; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_395, __v_396]; 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_494: G = __r_arr[0]; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_398, __v_399]; 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_495: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_489]; 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_496: G = __r_arr[0]; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_490, __v_491]; 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_497: G = __r_arr[0]; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_492, __v_493, __v_496]; 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_494, __v_495, __v_496, __v_497]; 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_498: G = G::from_u64(96); + if (__v_19 != __v_498) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_498.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); + } let __v_499: G = G::from_u64(256); - let __v_500: G = (__v_499 * __v_82); + let __v_500: G = (__v_499 * __v_74); let __v_501: G = G::from_u64(65536); - let __v_502: G = (__v_501 * __v_83); + let __v_502: G = (__v_501 * __v_75); let __v_503: G = G::from_u64(16777216); - let __v_504: G = (__v_503 * __v_84); + let __v_504: G = (__v_503 * __v_76); let __v_505: G = (__v_502 + __v_504); let __v_506: G = (__v_500 + __v_505); - let __v_507: G = (__v_81 + __v_506); + let __v_507: G = (__v_73 + __v_506); let __v_508: G = G::from_u64(256); - let __v_509: G = (__v_508 * __v_86); + let __v_509: G = (__v_508 * __v_78); let __v_510: G = G::from_u64(65536); - let __v_511: G = (__v_510 * __v_87); + let __v_511: G = (__v_510 * __v_79); let __v_512: G = G::from_u64(16777216); - let __v_513: G = (__v_512 * __v_88); + let __v_513: G = (__v_512 * __v_80); let __v_514: G = (__v_511 + __v_513); let __v_515: G = (__v_509 + __v_514); - let __v_516: G = (__v_85 + __v_515); + let __v_516: G = (__v_77 + __v_515); let __v_517: G = G::from_u64(256); - let __v_518: G = (__v_517 * __v_90); + let __v_518: G = (__v_517 * __v_82); let __v_519: G = G::from_u64(65536); - let __v_520: G = (__v_519 * __v_91); + let __v_520: G = (__v_519 * __v_83); let __v_521: G = G::from_u64(16777216); - let __v_522: G = (__v_521 * __v_92); + let __v_522: G = (__v_521 * __v_84); let __v_523: G = (__v_520 + __v_522); let __v_524: G = (__v_518 + __v_523); - let __v_525: G = (__v_89 + __v_524); + let __v_525: G = (__v_81 + __v_524); let __v_526: G = G::from_u64(256); - let __v_527: G = (__v_526 * __v_94); + let __v_527: G = (__v_526 * __v_86); let __v_528: G = G::from_u64(65536); - let __v_529: G = (__v_528 * __v_95); + let __v_529: G = (__v_528 * __v_87); let __v_530: G = G::from_u64(16777216); - let __v_531: G = (__v_530 * __v_96); + let __v_531: G = (__v_530 * __v_88); let __v_532: G = (__v_529 + __v_531); let __v_533: G = (__v_527 + __v_532); - let __v_534: G = (__v_93 + __v_533); + let __v_534: G = (__v_85 + __v_533); let __v_535: G = G::from_u64(256); - let __v_536: G = (__v_535 * __v_98); + let __v_536: G = (__v_535 * __v_90); let __v_537: G = G::from_u64(65536); - let __v_538: G = (__v_537 * __v_99); + let __v_538: G = (__v_537 * __v_91); let __v_539: G = G::from_u64(16777216); - let __v_540: G = (__v_539 * __v_100); + let __v_540: G = (__v_539 * __v_92); let __v_541: G = (__v_538 + __v_540); let __v_542: G = (__v_536 + __v_541); - let __v_543: G = (__v_97 + __v_542); + let __v_543: G = (__v_89 + __v_542); let __v_544: G = G::from_u64(256); - let __v_545: G = (__v_544 * __v_102); + let __v_545: G = (__v_544 * __v_94); let __v_546: G = G::from_u64(65536); - let __v_547: G = (__v_546 * __v_103); + let __v_547: G = (__v_546 * __v_95); let __v_548: G = G::from_u64(16777216); - let __v_549: G = (__v_548 * __v_104); + let __v_549: G = (__v_548 * __v_96); let __v_550: G = (__v_547 + __v_549); let __v_551: G = (__v_545 + __v_550); - let __v_552: G = (__v_101 + __v_551); - if (__v_489 != __v_0) { - return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_498 != __v_1) { - return Err(ExecError::AssertEqMismatch { lhs: __v_498.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_507 != __v_2) { - return Err(ExecError::AssertEqMismatch { lhs: __v_507.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_516 != __v_3) { - return Err(ExecError::AssertEqMismatch { lhs: __v_516.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_525 != __v_4) { - return Err(ExecError::AssertEqMismatch { lhs: __v_525.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_534 != __v_5) { - return Err(ExecError::AssertEqMismatch { lhs: __v_534.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_543 != __v_6) { - return Err(ExecError::AssertEqMismatch { lhs: __v_543.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_552 != __v_7) { - return Err(ExecError::AssertEqMismatch { lhs: __v_552.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_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_553: G = __loaded[0]; - let __v_554: G = __loaded[1]; - let __v_555: G = __loaded[2]; - let __v_556: G = G::from_u64(1); - let __v_557: G = G::from_u64(1); - if (__v_553 != __v_556) { - return Err(ExecError::AssertEqMismatch { lhs: __v_553.as_canonical_u64(), rhs: __v_556.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 88 bytes".to_string()) }); - } - if (__v_554 != __v_557) { - return Err(ExecError::AssertEqMismatch { lhs: __v_554.as_canonical_u64(), rhs: __v_557.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 88 bytes".to_string()) }); - } - if (__v_555 != __v_557) { - return Err(ExecError::AssertEqMismatch { lhs: __v_555.as_canonical_u64(), rhs: __v_557.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 88 bytes".to_string()) }); - } - let __v_558: G = G::from_u64(256); - let __v_559: G = (__v_558 * __v_234); - let __v_560: G = G::from_u64(65536); - let __v_561: G = (__v_560 * __v_235); - let __v_562: G = G::from_u64(16777216); - let __v_563: G = (__v_562 * __v_236); - let __v_564: G = (__v_561 + __v_563); - let __v_565: G = (__v_559 + __v_564); - let __v_566: G = (__v_233 + __v_565); - let __v_567: G = G::from_u64(256); - let __v_568: G = (__v_567 * __v_238); - let __v_569: G = G::from_u64(65536); - let __v_570: G = (__v_569 * __v_239); - let __v_571: G = G::from_u64(16777216); - let __v_572: G = (__v_571 * __v_240); - let __v_573: G = (__v_570 + __v_572); - let __v_574: G = (__v_568 + __v_573); - let __v_575: G = (__v_237 + __v_574); + let __v_552: G = (__v_93 + __v_551); + let __v_553: G = G::from_u64(256); + let __v_554: G = (__v_553 * __v_98); + let __v_555: G = G::from_u64(65536); + let __v_556: G = (__v_555 * __v_99); + let __v_557: G = G::from_u64(16777216); + let __v_558: G = (__v_557 * __v_100); + let __v_559: G = (__v_556 + __v_558); + let __v_560: G = (__v_554 + __v_559); + let __v_561: G = (__v_97 + __v_560); + let __v_562: G = G::from_u64(256); + let __v_563: G = (__v_562 * __v_102); + let __v_564: G = G::from_u64(65536); + let __v_565: G = (__v_564 * __v_103); + let __v_566: G = G::from_u64(16777216); + let __v_567: G = (__v_566 * __v_104); + let __v_568: G = (__v_565 + __v_567); + let __v_569: G = (__v_563 + __v_568); + let __v_570: G = (__v_101 + __v_569); + if (__v_507 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_507.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_516 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_516.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_525 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_525.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_534 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_534.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_543 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_543.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_552 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_552.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_561 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_561.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_570 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_570.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_571: G = __loaded[0]; + let __v_572: G = __loaded[1]; + let __v_573: G = __loaded[2]; + let __v_574: G = G::from_u64(1); + let __v_575: G = G::from_u64(1); + if (__v_571 != __v_574) { + return Err(ExecError::AssertEqMismatch { lhs: __v_571.as_canonical_u64(), rhs: __v_574.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); + } + if (__v_572 != __v_575) { + return Err(ExecError::AssertEqMismatch { lhs: __v_572.as_canonical_u64(), rhs: __v_575.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); + } + if (__v_573 != __v_575) { + return Err(ExecError::AssertEqMismatch { lhs: __v_573.as_canonical_u64(), rhs: __v_575.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); + } let __v_576: G = G::from_u64(256); - let __v_577: G = (__v_576 * __v_242); + let __v_577: G = (__v_576 * __v_251); let __v_578: G = G::from_u64(65536); - let __v_579: G = (__v_578 * __v_243); + let __v_579: G = (__v_578 * __v_252); let __v_580: G = G::from_u64(16777216); - let __v_581: G = (__v_580 * __v_244); + let __v_581: G = (__v_580 * __v_253); let __v_582: G = (__v_579 + __v_581); let __v_583: G = (__v_577 + __v_582); - let __v_584: G = (__v_241 + __v_583); + let __v_584: G = (__v_250 + __v_583); let __v_585: G = G::from_u64(256); - let __v_586: G = (__v_585 * __v_246); + let __v_586: G = (__v_585 * __v_255); let __v_587: G = G::from_u64(65536); - let __v_588: G = (__v_587 * __v_247); + let __v_588: G = (__v_587 * __v_256); let __v_589: G = G::from_u64(16777216); - let __v_590: G = (__v_589 * __v_248); + let __v_590: G = (__v_589 * __v_257); let __v_591: G = (__v_588 + __v_590); let __v_592: G = (__v_586 + __v_591); - let __v_593: G = (__v_245 + __v_592); + let __v_593: G = (__v_254 + __v_592); let __v_594: G = G::from_u64(256); - let __v_595: G = (__v_594 * __v_250); + let __v_595: G = (__v_594 * __v_259); let __v_596: G = G::from_u64(65536); - let __v_597: G = (__v_596 * __v_251); + let __v_597: G = (__v_596 * __v_260); let __v_598: G = G::from_u64(16777216); - let __v_599: G = (__v_598 * __v_252); + let __v_599: G = (__v_598 * __v_261); let __v_600: G = (__v_597 + __v_599); let __v_601: G = (__v_595 + __v_600); - let __v_602: G = (__v_249 + __v_601); + let __v_602: G = (__v_258 + __v_601); let __v_603: G = G::from_u64(256); - let __v_604: G = (__v_603 * __v_254); + let __v_604: G = (__v_603 * __v_263); let __v_605: G = G::from_u64(65536); - let __v_606: G = (__v_605 * __v_255); + let __v_606: G = (__v_605 * __v_264); let __v_607: G = G::from_u64(16777216); - let __v_608: G = (__v_607 * __v_256); + let __v_608: G = (__v_607 * __v_265); let __v_609: G = (__v_606 + __v_608); let __v_610: G = (__v_604 + __v_609); - let __v_611: G = (__v_253 + __v_610); + let __v_611: G = (__v_262 + __v_610); let __v_612: G = G::from_u64(256); - let __v_613: G = (__v_612 * __v_258); + let __v_613: G = (__v_612 * __v_267); let __v_614: G = G::from_u64(65536); - let __v_615: G = (__v_614 * __v_259); + let __v_615: G = (__v_614 * __v_268); let __v_616: G = G::from_u64(16777216); - let __v_617: G = (__v_616 * __v_260); + let __v_617: G = (__v_616 * __v_269); let __v_618: G = (__v_615 + __v_617); let __v_619: G = (__v_613 + __v_618); - let __v_620: G = (__v_257 + __v_619); + let __v_620: G = (__v_266 + __v_619); let __v_621: G = G::from_u64(256); - let __v_622: G = (__v_621 * __v_262); + let __v_622: G = (__v_621 * __v_271); let __v_623: G = G::from_u64(65536); - let __v_624: G = (__v_623 * __v_263); + let __v_624: G = (__v_623 * __v_272); let __v_625: G = G::from_u64(16777216); - let __v_626: G = (__v_625 * __v_264); + let __v_626: G = (__v_625 * __v_273); let __v_627: G = (__v_624 + __v_626); let __v_628: G = (__v_622 + __v_627); - let __v_629: G = (__v_261 + __v_628); - if (__v_566 != __v_165) { - return Err(ExecError::AssertEqMismatch { lhs: __v_566.as_canonical_u64(), rhs: __v_165.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_575 != __v_166) { - return Err(ExecError::AssertEqMismatch { lhs: __v_575.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_584 != __v_167) { - return Err(ExecError::AssertEqMismatch { lhs: __v_584.as_canonical_u64(), rhs: __v_167.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_593 != __v_168) { - return Err(ExecError::AssertEqMismatch { lhs: __v_593.as_canonical_u64(), rhs: __v_168.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_602 != __v_169) { - return Err(ExecError::AssertEqMismatch { lhs: __v_602.as_canonical_u64(), rhs: __v_169.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_611 != __v_170) { - return Err(ExecError::AssertEqMismatch { lhs: __v_611.as_canonical_u64(), rhs: __v_170.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_620 != __v_171) { - return Err(ExecError::AssertEqMismatch { lhs: __v_620.as_canonical_u64(), rhs: __v_171.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_629 != __v_172) { - return Err(ExecError::AssertEqMismatch { lhs: __v_629.as_canonical_u64(), rhs: __v_172.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_369.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_630: G = __loaded[0]; - let __v_631: G = __loaded[1]; - let __v_632: G = __loaded[2]; - let __v_633: G = G::from_u64(1); - let __v_634: G = G::from_u64(1); - if (__v_630 != __v_633) { - return Err(ExecError::AssertEqMismatch { lhs: __v_630.as_canonical_u64(), rhs: __v_633.as_canonical_u64(), msg: None }); - } - if (__v_631 != __v_634) { - return Err(ExecError::AssertEqMismatch { lhs: __v_631.as_canonical_u64(), rhs: __v_634.as_canonical_u64(), msg: None }); - } - if (__v_632 != __v_634) { - return Err(ExecError::AssertEqMismatch { lhs: __v_632.as_canonical_u64(), rhs: __v_634.as_canonical_u64(), msg: None }); - } - let __v_635: G = G::from_u64(256); - let __v_636: G = (__v_635 * __v_441); - let __v_637: G = G::from_u64(65536); - let __v_638: G = (__v_637 * __v_442); - let __v_639: G = G::from_u64(16777216); - let __v_640: G = (__v_639 * __v_443); - let __v_641: G = (__v_638 + __v_640); - let __v_642: G = (__v_636 + __v_641); - let __v_643: G = (__v_440 + __v_642); - let __v_644: G = G::from_u64(256); - let __v_645: G = (__v_644 * __v_445); - let __v_646: G = G::from_u64(65536); - let __v_647: G = (__v_646 * __v_446); - let __v_648: G = G::from_u64(16777216); - let __v_649: G = (__v_648 * __v_447); - let __v_650: G = (__v_647 + __v_649); - let __v_651: G = (__v_645 + __v_650); - let __v_652: G = (__v_444 + __v_651); + let __v_629: G = (__v_270 + __v_628); + let __v_630: G = G::from_u64(256); + let __v_631: G = (__v_630 * __v_275); + let __v_632: G = G::from_u64(65536); + let __v_633: G = (__v_632 * __v_276); + let __v_634: G = G::from_u64(16777216); + let __v_635: G = (__v_634 * __v_277); + let __v_636: G = (__v_633 + __v_635); + let __v_637: G = (__v_631 + __v_636); + let __v_638: G = (__v_274 + __v_637); + let __v_639: G = G::from_u64(256); + let __v_640: G = (__v_639 * __v_279); + let __v_641: G = G::from_u64(65536); + let __v_642: G = (__v_641 * __v_280); + let __v_643: G = G::from_u64(16777216); + let __v_644: G = (__v_643 * __v_281); + let __v_645: G = (__v_642 + __v_644); + let __v_646: G = (__v_640 + __v_645); + let __v_647: G = (__v_278 + __v_646); + if (__v_584 != __v_181) { + return Err(ExecError::AssertEqMismatch { lhs: __v_584.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_593 != __v_182) { + return Err(ExecError::AssertEqMismatch { lhs: __v_593.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_602 != __v_183) { + return Err(ExecError::AssertEqMismatch { lhs: __v_602.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_611 != __v_184) { + return Err(ExecError::AssertEqMismatch { lhs: __v_611.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_620 != __v_185) { + return Err(ExecError::AssertEqMismatch { lhs: __v_620.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_629 != __v_186) { + return Err(ExecError::AssertEqMismatch { lhs: __v_629.as_canonical_u64(), rhs: __v_186.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_638 != __v_187) { + return Err(ExecError::AssertEqMismatch { lhs: __v_638.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_647 != __v_188) { + return Err(ExecError::AssertEqMismatch { lhs: __v_647.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_648: G = __loaded[0]; + let __v_649: G = __loaded[1]; + let __v_650: G = __loaded[2]; + let __v_651: G = G::from_u64(1); + let __v_652: G = G::from_u64(1); + if (__v_648 != __v_651) { + return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_651.as_canonical_u64(), msg: None }); + } + if (__v_649 != __v_652) { + return Err(ExecError::AssertEqMismatch { lhs: __v_649.as_canonical_u64(), rhs: __v_652.as_canonical_u64(), msg: None }); + } + if (__v_650 != __v_652) { + return Err(ExecError::AssertEqMismatch { lhs: __v_650.as_canonical_u64(), rhs: __v_652.as_canonical_u64(), msg: None }); + } let __v_653: G = G::from_u64(256); - let __v_654: G = (__v_653 * __v_449); + let __v_654: G = (__v_653 * __v_458); let __v_655: G = G::from_u64(65536); - let __v_656: G = (__v_655 * __v_450); + let __v_656: G = (__v_655 * __v_459); let __v_657: G = G::from_u64(16777216); - let __v_658: G = (__v_657 * __v_451); + let __v_658: G = (__v_657 * __v_460); let __v_659: G = (__v_656 + __v_658); let __v_660: G = (__v_654 + __v_659); - let __v_661: G = (__v_448 + __v_660); + let __v_661: G = (__v_457 + __v_660); let __v_662: G = G::from_u64(256); - let __v_663: G = (__v_662 * __v_453); + let __v_663: G = (__v_662 * __v_462); let __v_664: G = G::from_u64(65536); - let __v_665: G = (__v_664 * __v_454); + let __v_665: G = (__v_664 * __v_463); let __v_666: G = G::from_u64(16777216); - let __v_667: G = (__v_666 * __v_455); + let __v_667: G = (__v_666 * __v_464); let __v_668: G = (__v_665 + __v_667); let __v_669: G = (__v_663 + __v_668); - let __v_670: G = (__v_452 + __v_669); + let __v_670: G = (__v_461 + __v_669); let __v_671: G = G::from_u64(256); - let __v_672: G = (__v_671 * __v_457); + let __v_672: G = (__v_671 * __v_466); let __v_673: G = G::from_u64(65536); - let __v_674: G = (__v_673 * __v_458); + let __v_674: G = (__v_673 * __v_467); let __v_675: G = G::from_u64(16777216); - let __v_676: G = (__v_675 * __v_459); + let __v_676: G = (__v_675 * __v_468); let __v_677: G = (__v_674 + __v_676); let __v_678: G = (__v_672 + __v_677); - let __v_679: G = (__v_456 + __v_678); + let __v_679: G = (__v_465 + __v_678); let __v_680: G = G::from_u64(256); - let __v_681: G = (__v_680 * __v_461); + let __v_681: G = (__v_680 * __v_470); let __v_682: G = G::from_u64(65536); - let __v_683: G = (__v_682 * __v_462); + let __v_683: G = (__v_682 * __v_471); let __v_684: G = G::from_u64(16777216); - let __v_685: G = (__v_684 * __v_463); + let __v_685: G = (__v_684 * __v_472); let __v_686: G = (__v_683 + __v_685); let __v_687: G = (__v_681 + __v_686); - let __v_688: G = (__v_460 + __v_687); + let __v_688: G = (__v_469 + __v_687); let __v_689: G = G::from_u64(256); - let __v_690: G = (__v_689 * __v_465); + let __v_690: G = (__v_689 * __v_474); let __v_691: G = G::from_u64(65536); - let __v_692: G = (__v_691 * __v_466); + let __v_692: G = (__v_691 * __v_475); let __v_693: G = G::from_u64(16777216); - let __v_694: G = (__v_693 * __v_467); + let __v_694: G = (__v_693 * __v_476); let __v_695: G = (__v_692 + __v_694); let __v_696: G = (__v_690 + __v_695); - let __v_697: G = (__v_464 + __v_696); + let __v_697: G = (__v_473 + __v_696); let __v_698: G = G::from_u64(256); - let __v_699: G = (__v_698 * __v_469); + let __v_699: G = (__v_698 * __v_478); let __v_700: G = G::from_u64(65536); - let __v_701: G = (__v_700 * __v_470); + let __v_701: G = (__v_700 * __v_479); let __v_702: G = G::from_u64(16777216); - let __v_703: G = (__v_702 * __v_471); + let __v_703: G = (__v_702 * __v_480); let __v_704: G = (__v_701 + __v_703); let __v_705: G = (__v_699 + __v_704); - let __v_706: G = (__v_468 + __v_705); - if (__v_643 != __v_8) { - return Err(ExecError::AssertEqMismatch { lhs: __v_643.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_652 != __v_9) { - return Err(ExecError::AssertEqMismatch { lhs: __v_652.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_661 != __v_10) { - return Err(ExecError::AssertEqMismatch { lhs: __v_661.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_670 != __v_11) { - return Err(ExecError::AssertEqMismatch { lhs: __v_670.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_679 != __v_12) { - return Err(ExecError::AssertEqMismatch { lhs: __v_679.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_688 != __v_13) { - return Err(ExecError::AssertEqMismatch { lhs: __v_688.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_697 != __v_14) { - return Err(ExecError::AssertEqMismatch { lhs: __v_697.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_706 != __v_15) { - return Err(ExecError::AssertEqMismatch { lhs: __v_706.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - let __ret: [G; OUT_224] = []; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_706: G = (__v_477 + __v_705); + let __v_707: G = G::from_u64(256); + let __v_708: G = (__v_707 * __v_482); + let __v_709: G = G::from_u64(65536); + let __v_710: G = (__v_709 * __v_483); + let __v_711: G = G::from_u64(16777216); + let __v_712: G = (__v_711 * __v_484); + let __v_713: G = (__v_710 + __v_712); + let __v_714: G = (__v_708 + __v_713); + let __v_715: G = (__v_481 + __v_714); + let __v_716: G = G::from_u64(256); + let __v_717: G = (__v_716 * __v_486); + let __v_718: G = G::from_u64(65536); + let __v_719: G = (__v_718 * __v_487); + let __v_720: G = G::from_u64(16777216); + let __v_721: G = (__v_720 * __v_488); + let __v_722: G = (__v_719 + __v_721); + let __v_723: G = (__v_717 + __v_722); + let __v_724: G = (__v_485 + __v_723); + if (__v_661 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_661.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_670 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_670.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_679 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_679.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_688 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_688.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_697 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_697.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_706 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_706.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_715 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_715.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_724 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_724.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_225: usize = 16; -const IN_225: usize = 16; -const OUT_225: usize = 0; -fn aiur_fn_225( - inp: [G; IN_225], +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_225], ExecError> { +) -> 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(0); + let __v_388: G = { let __values: [G; 10] = [__v_387, __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 __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_368, __v_388]; 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_389: G = __r_arr[0]; + let __v_390: 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_389, __v_379, __v_382, __v_383, __v_385, __v_390]; 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_391: G = __r_arr[0]; + let __v_392: 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_389, __v_379, __v_382, __v_383, __v_385, __v_392]; 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_393: G = __r_arr[0]; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_391, __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_394: G = __r_arr[0]; + let __v_395: G = __r_arr[1]; + let __v_396: G = __r_arr[2]; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_393, __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_397: G = __r_arr[0]; + let __v_398: G = __r_arr[1]; + let __v_399: G = __r_arr[2]; + let __v_400: G = G::from_u64(2); + let __v_401: G = G::from_u64(2); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_401]; let __info = io_buffer.get_info(__v_400, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_402: G = __io_pair.0; + let __v_403: G = __io_pair.1; + let __v_404: G = G::from_u64(2); + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_404, __v_402, __v_403]; 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_405: G = __r_arr[0]; + let __v_406: G = G::from_u64(103); + let __v_407: G = G::from_u64(230); + let __v_408: G = G::from_u64(9); + let __v_409: G = G::from_u64(106); + let __v_410: G = G::from_u64(133); + let __v_411: G = G::from_u64(174); + let __v_412: G = G::from_u64(103); + let __v_413: G = G::from_u64(187); + let __v_414: G = G::from_u64(114); + let __v_415: G = G::from_u64(243); + let __v_416: G = G::from_u64(110); + let __v_417: G = G::from_u64(60); + let __v_418: G = G::from_u64(58); + let __v_419: G = G::from_u64(245); + let __v_420: G = G::from_u64(79); + let __v_421: G = G::from_u64(165); + let __v_422: G = G::from_u64(127); + let __v_423: G = G::from_u64(82); + let __v_424: G = G::from_u64(14); + let __v_425: G = G::from_u64(81); + let __v_426: G = G::from_u64(140); + let __v_427: G = G::from_u64(104); + let __v_428: G = G::from_u64(5); + let __v_429: G = G::from_u64(155); + let __v_430: G = G::from_u64(171); + let __v_431: G = G::from_u64(217); + let __v_432: G = G::from_u64(131); + let __v_433: G = G::from_u64(31); + let __v_434: G = G::from_u64(25); + let __v_435: G = G::from_u64(205); + let __v_436: G = G::from_u64(224); + let __v_437: G = G::from_u64(91); + let __v_438: G = G::from_u64(1); + let __v_439: G = G::from_u64(1); + let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_441: G = G::from_u64(0); + let __v_442: G = G::from_u64(0); + let __v_443: G = G::from_u64(0); + let __v_444: G = G::from_u64(0); + let __v_445: G = G::from_u64(0); + let __v_446: G = G::from_u64(0); + let __v_447: G = G::from_u64(0); + let __v_448: G = G::from_u64(0); + let __v_449: G = G::from_u64(0); + let __v_450: G = G::from_u64(0); + let __v_451: G = { let __values: [G; 8] = [__v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_449, __v_450]; 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_452: G = { let __values: [G; 32] = [__v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1); + let __v_454: G = G::from_u64(1); + let __v_455: G = { let __values: [G; 34] = [__v_453, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454]; 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_405, __v_440, __v_441, __v_442, __v_451, __v_452, __v_455]; 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_456: G = __r_arr[0]; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_456]; 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_457: G = __r_arr[0]; + let __v_458: G = __r_arr[1]; + let __v_459: G = __r_arr[2]; + let __v_460: G = __r_arr[3]; + let __v_461: G = __r_arr[4]; + let __v_462: G = __r_arr[5]; + let __v_463: G = __r_arr[6]; + let __v_464: G = __r_arr[7]; + let __v_465: G = __r_arr[8]; + let __v_466: G = __r_arr[9]; + let __v_467: G = __r_arr[10]; + let __v_468: G = __r_arr[11]; + let __v_469: G = __r_arr[12]; + let __v_470: G = __r_arr[13]; + let __v_471: G = __r_arr[14]; + let __v_472: G = __r_arr[15]; + let __v_473: G = __r_arr[16]; + let __v_474: G = __r_arr[17]; + let __v_475: G = __r_arr[18]; + let __v_476: G = __r_arr[19]; + let __v_477: G = __r_arr[20]; + let __v_478: G = __r_arr[21]; + let __v_479: G = __r_arr[22]; + let __v_480: G = __r_arr[23]; + let __v_481: G = __r_arr[24]; + let __v_482: G = __r_arr[25]; + let __v_483: G = __r_arr[26]; + let __v_484: G = __r_arr[27]; + let __v_485: G = __r_arr[28]; + let __v_486: G = __r_arr[29]; + let __v_487: G = __r_arr[30]; + let __v_488: G = __r_arr[31]; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_405]; 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_489: G = __r_arr[0]; + let __v_490: G = __r_arr[1]; + let __v_491: G = __r_arr[2]; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_394, __v_397]; 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_492: G = __r_arr[0]; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_395, __v_396]; 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_493: G = __r_arr[0]; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_398, __v_399]; 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_494: G = __r_arr[0]; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_490, __v_491]; 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_495: G = __r_arr[0]; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_493, __v_494, __v_489, __v_495]; 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_496: G = G::from_u64(96); + if (__v_19 != __v_496) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_496.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); + } + let __v_497: G = G::from_u64(256); + let __v_498: G = (__v_497 * __v_74); + let __v_499: G = G::from_u64(65536); + let __v_500: G = (__v_499 * __v_75); + let __v_501: G = G::from_u64(16777216); + let __v_502: G = (__v_501 * __v_76); + let __v_503: G = (__v_500 + __v_502); + let __v_504: G = (__v_498 + __v_503); + let __v_505: G = (__v_73 + __v_504); + let __v_506: G = G::from_u64(256); + let __v_507: G = (__v_506 * __v_78); + let __v_508: G = G::from_u64(65536); + let __v_509: G = (__v_508 * __v_79); + let __v_510: G = G::from_u64(16777216); + let __v_511: G = (__v_510 * __v_80); + let __v_512: G = (__v_509 + __v_511); + let __v_513: G = (__v_507 + __v_512); + let __v_514: G = (__v_77 + __v_513); + let __v_515: G = G::from_u64(256); + let __v_516: G = (__v_515 * __v_82); + let __v_517: G = G::from_u64(65536); + let __v_518: G = (__v_517 * __v_83); + let __v_519: G = G::from_u64(16777216); + let __v_520: G = (__v_519 * __v_84); + let __v_521: G = (__v_518 + __v_520); + let __v_522: G = (__v_516 + __v_521); + let __v_523: G = (__v_81 + __v_522); + let __v_524: G = G::from_u64(256); + let __v_525: G = (__v_524 * __v_86); + let __v_526: G = G::from_u64(65536); + let __v_527: G = (__v_526 * __v_87); + let __v_528: G = G::from_u64(16777216); + let __v_529: G = (__v_528 * __v_88); + let __v_530: G = (__v_527 + __v_529); + let __v_531: G = (__v_525 + __v_530); + let __v_532: G = (__v_85 + __v_531); + let __v_533: G = G::from_u64(256); + let __v_534: G = (__v_533 * __v_90); + let __v_535: G = G::from_u64(65536); + let __v_536: G = (__v_535 * __v_91); + let __v_537: G = G::from_u64(16777216); + let __v_538: G = (__v_537 * __v_92); + let __v_539: G = (__v_536 + __v_538); + let __v_540: G = (__v_534 + __v_539); + let __v_541: G = (__v_89 + __v_540); + let __v_542: G = G::from_u64(256); + let __v_543: G = (__v_542 * __v_94); + let __v_544: G = G::from_u64(65536); + let __v_545: G = (__v_544 * __v_95); + let __v_546: G = G::from_u64(16777216); + let __v_547: G = (__v_546 * __v_96); + let __v_548: G = (__v_545 + __v_547); + let __v_549: G = (__v_543 + __v_548); + let __v_550: G = (__v_93 + __v_549); + let __v_551: G = G::from_u64(256); + let __v_552: G = (__v_551 * __v_98); + let __v_553: G = G::from_u64(65536); + let __v_554: G = (__v_553 * __v_99); + let __v_555: G = G::from_u64(16777216); + let __v_556: G = (__v_555 * __v_100); + let __v_557: G = (__v_554 + __v_556); + let __v_558: G = (__v_552 + __v_557); + let __v_559: G = (__v_97 + __v_558); + let __v_560: G = G::from_u64(256); + let __v_561: G = (__v_560 * __v_102); + let __v_562: G = G::from_u64(65536); + let __v_563: G = (__v_562 * __v_103); + let __v_564: G = G::from_u64(16777216); + let __v_565: G = (__v_564 * __v_104); + let __v_566: G = (__v_563 + __v_565); + let __v_567: G = (__v_561 + __v_566); + let __v_568: G = (__v_101 + __v_567); + if (__v_505 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_505.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_514 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_523 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_532 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_532.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_541 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_541.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_550 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_550.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_559 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_559.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_568 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_568.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_569: G = __loaded[0]; + let __v_570: G = __loaded[1]; + let __v_571: G = __loaded[2]; + let __v_572: G = G::from_u64(1); + let __v_573: G = G::from_u64(1); + if (__v_569 != __v_572) { + return Err(ExecError::AssertEqMismatch { lhs: __v_569.as_canonical_u64(), rhs: __v_572.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); + } + if (__v_570 != __v_573) { + return Err(ExecError::AssertEqMismatch { lhs: __v_570.as_canonical_u64(), rhs: __v_573.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); + } + if (__v_571 != __v_573) { + return Err(ExecError::AssertEqMismatch { lhs: __v_571.as_canonical_u64(), rhs: __v_573.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); + } + let __v_574: G = G::from_u64(256); + let __v_575: G = (__v_574 * __v_251); + let __v_576: G = G::from_u64(65536); + let __v_577: G = (__v_576 * __v_252); + let __v_578: G = G::from_u64(16777216); + let __v_579: G = (__v_578 * __v_253); + let __v_580: G = (__v_577 + __v_579); + let __v_581: G = (__v_575 + __v_580); + let __v_582: G = (__v_250 + __v_581); + let __v_583: G = G::from_u64(256); + let __v_584: G = (__v_583 * __v_255); + let __v_585: G = G::from_u64(65536); + let __v_586: G = (__v_585 * __v_256); + let __v_587: G = G::from_u64(16777216); + let __v_588: G = (__v_587 * __v_257); + let __v_589: G = (__v_586 + __v_588); + let __v_590: G = (__v_584 + __v_589); + let __v_591: G = (__v_254 + __v_590); + let __v_592: G = G::from_u64(256); + let __v_593: G = (__v_592 * __v_259); + let __v_594: G = G::from_u64(65536); + let __v_595: G = (__v_594 * __v_260); + let __v_596: G = G::from_u64(16777216); + let __v_597: G = (__v_596 * __v_261); + let __v_598: G = (__v_595 + __v_597); + let __v_599: G = (__v_593 + __v_598); + let __v_600: G = (__v_258 + __v_599); + let __v_601: G = G::from_u64(256); + let __v_602: G = (__v_601 * __v_263); + let __v_603: G = G::from_u64(65536); + let __v_604: G = (__v_603 * __v_264); + let __v_605: G = G::from_u64(16777216); + let __v_606: G = (__v_605 * __v_265); + let __v_607: G = (__v_604 + __v_606); + let __v_608: G = (__v_602 + __v_607); + let __v_609: G = (__v_262 + __v_608); + let __v_610: G = G::from_u64(256); + let __v_611: G = (__v_610 * __v_267); + let __v_612: G = G::from_u64(65536); + let __v_613: G = (__v_612 * __v_268); + let __v_614: G = G::from_u64(16777216); + let __v_615: G = (__v_614 * __v_269); + let __v_616: G = (__v_613 + __v_615); + let __v_617: G = (__v_611 + __v_616); + let __v_618: G = (__v_266 + __v_617); + let __v_619: G = G::from_u64(256); + let __v_620: G = (__v_619 * __v_271); + let __v_621: G = G::from_u64(65536); + let __v_622: G = (__v_621 * __v_272); + let __v_623: G = G::from_u64(16777216); + let __v_624: G = (__v_623 * __v_273); + let __v_625: G = (__v_622 + __v_624); + let __v_626: G = (__v_620 + __v_625); + let __v_627: G = (__v_270 + __v_626); + let __v_628: G = G::from_u64(256); + let __v_629: G = (__v_628 * __v_275); + let __v_630: G = G::from_u64(65536); + let __v_631: G = (__v_630 * __v_276); + let __v_632: G = G::from_u64(16777216); + let __v_633: G = (__v_632 * __v_277); + let __v_634: G = (__v_631 + __v_633); + let __v_635: G = (__v_629 + __v_634); + let __v_636: G = (__v_274 + __v_635); + let __v_637: G = G::from_u64(256); + let __v_638: G = (__v_637 * __v_279); + let __v_639: G = G::from_u64(65536); + let __v_640: G = (__v_639 * __v_280); + let __v_641: G = G::from_u64(16777216); + let __v_642: G = (__v_641 * __v_281); + let __v_643: G = (__v_640 + __v_642); + let __v_644: G = (__v_638 + __v_643); + let __v_645: G = (__v_278 + __v_644); + if (__v_582 != __v_181) { + return Err(ExecError::AssertEqMismatch { lhs: __v_582.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_591 != __v_182) { + return Err(ExecError::AssertEqMismatch { lhs: __v_591.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_600 != __v_183) { + return Err(ExecError::AssertEqMismatch { lhs: __v_600.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_609 != __v_184) { + return Err(ExecError::AssertEqMismatch { lhs: __v_609.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_618 != __v_185) { + return Err(ExecError::AssertEqMismatch { lhs: __v_618.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_627 != __v_186) { + return Err(ExecError::AssertEqMismatch { lhs: __v_627.as_canonical_u64(), rhs: __v_186.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_636 != __v_187) { + return Err(ExecError::AssertEqMismatch { lhs: __v_636.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_645 != __v_188) { + return Err(ExecError::AssertEqMismatch { lhs: __v_645.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_646: G = __loaded[0]; + let __v_647: G = __loaded[1]; + let __v_648: G = __loaded[2]; + let __v_649: G = G::from_u64(1); + let __v_650: G = G::from_u64(1); + if (__v_646 != __v_649) { + return Err(ExecError::AssertEqMismatch { lhs: __v_646.as_canonical_u64(), rhs: __v_649.as_canonical_u64(), msg: None }); + } + if (__v_647 != __v_650) { + return Err(ExecError::AssertEqMismatch { lhs: __v_647.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: None }); + } + if (__v_648 != __v_650) { + return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: None }); + } + let __v_651: G = G::from_u64(256); + let __v_652: G = (__v_651 * __v_458); + let __v_653: G = G::from_u64(65536); + let __v_654: G = (__v_653 * __v_459); + let __v_655: G = G::from_u64(16777216); + let __v_656: G = (__v_655 * __v_460); + let __v_657: G = (__v_654 + __v_656); + let __v_658: G = (__v_652 + __v_657); + let __v_659: G = (__v_457 + __v_658); + let __v_660: G = G::from_u64(256); + let __v_661: G = (__v_660 * __v_462); + let __v_662: G = G::from_u64(65536); + let __v_663: G = (__v_662 * __v_463); + let __v_664: G = G::from_u64(16777216); + let __v_665: G = (__v_664 * __v_464); + let __v_666: G = (__v_663 + __v_665); + let __v_667: G = (__v_661 + __v_666); + let __v_668: G = (__v_461 + __v_667); + let __v_669: G = G::from_u64(256); + let __v_670: G = (__v_669 * __v_466); + let __v_671: G = G::from_u64(65536); + let __v_672: G = (__v_671 * __v_467); + let __v_673: G = G::from_u64(16777216); + let __v_674: G = (__v_673 * __v_468); + let __v_675: G = (__v_672 + __v_674); + let __v_676: G = (__v_670 + __v_675); + let __v_677: G = (__v_465 + __v_676); + let __v_678: G = G::from_u64(256); + let __v_679: G = (__v_678 * __v_470); + let __v_680: G = G::from_u64(65536); + let __v_681: G = (__v_680 * __v_471); + let __v_682: G = G::from_u64(16777216); + let __v_683: G = (__v_682 * __v_472); + let __v_684: G = (__v_681 + __v_683); + let __v_685: G = (__v_679 + __v_684); + let __v_686: G = (__v_469 + __v_685); + let __v_687: G = G::from_u64(256); + let __v_688: G = (__v_687 * __v_474); + let __v_689: G = G::from_u64(65536); + let __v_690: G = (__v_689 * __v_475); + let __v_691: G = G::from_u64(16777216); + let __v_692: G = (__v_691 * __v_476); + let __v_693: G = (__v_690 + __v_692); + let __v_694: G = (__v_688 + __v_693); + let __v_695: G = (__v_473 + __v_694); + let __v_696: G = G::from_u64(256); + let __v_697: G = (__v_696 * __v_478); + let __v_698: G = G::from_u64(65536); + let __v_699: G = (__v_698 * __v_479); + let __v_700: G = G::from_u64(16777216); + let __v_701: G = (__v_700 * __v_480); + let __v_702: G = (__v_699 + __v_701); + let __v_703: G = (__v_697 + __v_702); + let __v_704: G = (__v_477 + __v_703); + let __v_705: G = G::from_u64(256); + let __v_706: G = (__v_705 * __v_482); + let __v_707: G = G::from_u64(65536); + let __v_708: G = (__v_707 * __v_483); + let __v_709: G = G::from_u64(16777216); + let __v_710: G = (__v_709 * __v_484); + let __v_711: G = (__v_708 + __v_710); + let __v_712: G = (__v_706 + __v_711); + let __v_713: G = (__v_481 + __v_712); + let __v_714: G = G::from_u64(256); + let __v_715: G = (__v_714 * __v_486); + let __v_716: G = G::from_u64(65536); + let __v_717: G = (__v_716 * __v_487); + let __v_718: G = G::from_u64(16777216); + let __v_719: G = (__v_718 * __v_488); + let __v_720: G = (__v_717 + __v_719); + let __v_721: G = (__v_715 + __v_720); + let __v_722: G = (__v_485 + __v_721); + if (__v_659 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_659.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_668 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_668.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_677 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_677.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_686 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_686.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_695 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_695.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_704 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_704.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_713 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_713.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_722 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_722.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_489, __v_492]; 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_723: G = __r_arr[0]; + let __v_724: G = G::from_u64(1); + if (__v_723 != __v_724) { + return Err(ExecError::AssertEqMismatch { lhs: __v_723.as_canonical_u64(), rhs: __v_724.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]; @@ -23216,7 +24441,7 @@ fn aiur_fn_225( 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_231] = { let __args: [G; IN_231] = [__v_241, __v_261]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_241, __v_261]; 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_262: G = __r_arr[0]; let __v_263: G = G::from_u64(2); let __v_264: G = G::from_u64(0); @@ -23319,24 +24544,24 @@ fn aiur_fn_225( let __v_355: G = __r_arr[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_22.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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_238] = { let __args: [G; IN_238] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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_238] = { let __args: [G; IN_238] = [__v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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_238] = { let __args: [G; IN_238] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_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 }); @@ -23462,7 +24687,7 @@ fn aiur_fn_225( let __v_431: G = __r_arr[0]; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_432: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_426, __v_432]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_426, __v_432]; 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_433: G = __r_arr[0]; let __v_434: G = G::from_u64(1); let __v_435: G = G::from_u64(1); @@ -23493,7 +24718,7 @@ fn aiur_fn_225( let __v_458: G = __r_arr[0]; let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_459: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_453, __v_459]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_453, __v_459]; 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_460: G = __r_arr[0]; let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_460, __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_461: G = __r_arr[0]; @@ -23502,7 +24727,7 @@ fn aiur_fn_225( 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_119] = { let __args: [G; IN_119] = [__v_30, __v_464]; 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_465: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_461, __v_465]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_461, __v_465]; 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_466: G = __r_arr[0]; let __v_467: G = G::from_u64(1); let __v_468: G = G::from_u64(1); @@ -23726,11 +24951,11 @@ fn aiur_fn_225( let __v_682: G = G::from_u64(0); let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__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[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_683: G = __r_arr[0]; - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_357]; 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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_357]; 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_684: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_685: G = __r_arr[0]; let __v_686: G = G::from_u64(1); let __v_687: G = G::from_u64(1); @@ -23756,7 +24981,7 @@ fn aiur_fn_225( let __v_691: G = __r_arr[0]; let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_62, __v_691]; 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_692: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_508, __v_692]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_508, __v_692]; 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_693: G = __r_arr[0]; let __v_694: G = G::from_u64(1); let __v_695: G = G::from_u64(1); @@ -23830,7 +25055,7 @@ fn aiur_fn_225( 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_119] = { let __args: [G; IN_119] = [__v_46, __v_761]; 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_762: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_758, __v_762]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_758, __v_762]; 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_763: G = __r_arr[0]; let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_763, __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_764: G = __r_arr[0]; @@ -23844,9 +25069,9 @@ fn aiur_fn_225( if (__v_768 != __v_769) { return Err(ExecError::AssertEqMismatch { lhs: __v_768.as_canonical_u64(), rhs: __v_769.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_770: G = __r_arr[0]; - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_252]; 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 __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_771: G = __r_arr[0]; let __v_772: G = (__v_770 - __v_771); let __v_773: G = G::from_bool((__v_772 == G::ZERO)); @@ -23854,9 +25079,9 @@ fn aiur_fn_225( 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_237] = { let __args: [G; IN_237] = [__v_357]; 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 __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_357]; 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_775: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_776: G = __r_arr[0]; let __v_777: G = (__v_775 - __v_776); let __v_778: G = G::from_bool((__v_777 == G::ZERO)); @@ -23864,7 +25089,7 @@ fn aiur_fn_225( 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_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 __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_780: G = __r_arr[0]; let __v_781: G = (__v_780 - __v_685); let __v_782: G = G::from_bool((__v_781 == G::ZERO)); @@ -23872,7 +25097,7 @@ fn aiur_fn_225( 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_230] = { let __args: [G; IN_230] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_784: G = __r_arr[0]; let __v_785: G = (__v_784 - __v_195); let __v_786: G = G::from_bool((__v_785 == G::ZERO)); @@ -23880,7 +25105,7 @@ fn aiur_fn_225( 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_230] = { let __args: [G; IN_230] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_788: G = __r_arr[0]; let __v_789: G = G::from_u64(1); if (__v_788 != __v_789) { @@ -24141,25 +25366,25 @@ fn aiur_fn_225( 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_225] = []; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_226: usize = 2; -const IN_226: usize = 2; -const OUT_226: usize = 1; -fn aiur_fn_226( - inp: [G; IN_226], +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_226], 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_233] = { let __args: [G; IN_233] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -24167,8 +25392,8 @@ fn aiur_fn_226( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_226] = [__v_4]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24178,15 +25403,15 @@ fn aiur_fn_226( }) } -const INPUT_SIZE_227: usize = 1; -const IN_227: usize = 1; -const OUT_227: usize = 1; -fn aiur_fn_227( - inp: [G; IN_227], +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_227], 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 }; @@ -24196,14 +25421,14 @@ fn aiur_fn_227( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_227] = [__v_4]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_227] = [__v_4]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24213,19 +25438,19 @@ fn aiur_fn_227( }) } -const INPUT_SIZE_228: usize = 2; -const IN_228: usize = 2; -const OUT_228: usize = 2; -fn aiur_fn_228( - inp: [G; IN_228], +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_228], 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_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 __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]; @@ -24234,8 +25459,8 @@ fn aiur_fn_228( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_228] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24245,15 +25470,15 @@ fn aiur_fn_228( }) } -const INPUT_SIZE_229: usize = 1; -const IN_229: usize = 1; -const OUT_229: usize = 1; -fn aiur_fn_229( - inp: [G; IN_229], +const INPUT_SIZE_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_229], 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 }; @@ -24265,17 +25490,17 @@ fn aiur_fn_229( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_229] = [__v_6]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = [__v_8]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24285,15 +25510,15 @@ fn aiur_fn_229( }) } -const INPUT_SIZE_230: usize = 1; -const IN_230: usize = 1; -const OUT_230: usize = 1; -fn aiur_fn_230( - inp: [G; IN_230], +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_230], 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 }; @@ -24304,17 +25529,17 @@ fn aiur_fn_230( match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_230] = [__v_5]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_230] = { let __args: [G; IN_230] = [__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 __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_230] = [__v_7]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24324,15 +25549,15 @@ fn aiur_fn_230( }) } -const INPUT_SIZE_231: usize = 2; -const IN_231: usize = 2; -const OUT_231: usize = 1; -fn aiur_fn_231( - inp: [G; IN_231], +const INPUT_SIZE_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_231], 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]; @@ -24349,17 +25574,17 @@ fn aiur_fn_231( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_231] = [__v_1]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_231] = { let __args: [G; IN_231] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_231] = [__v_14]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24369,15 +25594,15 @@ fn aiur_fn_231( }) } -const INPUT_SIZE_232: usize = 2; -const IN_232: usize = 2; -const OUT_232: usize = 1; -fn aiur_fn_232( - inp: [G; IN_232], +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_232], 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]; @@ -24387,17 +25612,17 @@ fn aiur_fn_232( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_232] = [__v_1]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_232] = { let __args: [G; IN_232] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_232] = [__v_7]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24407,28 +25632,28 @@ fn aiur_fn_232( }) } -const INPUT_SIZE_233: usize = 2; -const IN_233: usize = 2; -const OUT_233: usize = 1; -fn aiur_fn_233( - inp: [G; IN_233], +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_233], 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_233] = [__v_0]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_233] = { let __args: [G; IN_233] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -24436,8 +25661,8 @@ fn aiur_fn_233( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_233] = [__v_7]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24449,15 +25674,15 @@ fn aiur_fn_233( }) } -const INPUT_SIZE_234: usize = 1; -const IN_234: usize = 1; -const OUT_234: usize = 1; -fn aiur_fn_234( - inp: [G; IN_234], +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_234], 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 }; @@ -24471,17 +25696,17 @@ fn aiur_fn_234( match __v_1.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - 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)); }; + 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_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 __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_234] = [__v_10]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24491,15 +25716,15 @@ fn aiur_fn_234( }) } -const INPUT_SIZE_235: usize = 1; -const IN_235: usize = 1; -const OUT_235: usize = 1; -fn aiur_fn_235( - inp: [G; IN_235], +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_235], 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 }; @@ -24516,17 +25741,17 @@ fn aiur_fn_235( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_235] = [__v_11]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_235] = { let __args: [G; IN_235] = [__v_10]; 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 __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_235] = [__v_13]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24536,19 +25761,19 @@ fn aiur_fn_235( }) } -const INPUT_SIZE_236: usize = 2; -const IN_236: usize = 2; -const OUT_236: usize = 4; -fn aiur_fn_236( - inp: [G; IN_236], +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_236], 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_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 __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]; @@ -24559,8 +25784,8 @@ fn aiur_fn_236( let __v_8: G = __loaded[5]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_236] = [__v_4, __v_5, __v_6, __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)); }; + 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); }, _ => { @@ -24570,15 +25795,15 @@ fn aiur_fn_236( }) } -const INPUT_SIZE_237: usize = 1; -const IN_237: usize = 1; -const OUT_237: usize = 1; -fn aiur_fn_237( - inp: [G; IN_237], +const INPUT_SIZE_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_237], 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 }; @@ -24593,17 +25818,17 @@ fn aiur_fn_237( match __v_1.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_237] = [__v_9]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_237] = { let __args: [G; IN_237] = [__v_8]; 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 __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_237] = [__v_11]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24613,15 +25838,15 @@ fn aiur_fn_237( }) } -const INPUT_SIZE_238: usize = 1; -const IN_238: usize = 1; -const OUT_238: usize = 1; -fn aiur_fn_238( - inp: [G; IN_238], +const INPUT_SIZE_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_238], 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 }; @@ -24631,17 +25856,17 @@ fn aiur_fn_238( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_238] = [__v_4]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_238] = { let __args: [G; IN_238] = [__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 __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_238] = [__v_6]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24651,19 +25876,19 @@ fn aiur_fn_238( }) } -const INPUT_SIZE_239: usize = 2; -const IN_239: usize = 2; -const OUT_239: usize = 8; -fn aiur_fn_239( - inp: [G; IN_239], +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_239], 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_242] = { let __args: [G; IN_242] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -24678,8 +25903,8 @@ fn aiur_fn_239( let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_239] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __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)); }; + 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); }, _ => { @@ -24689,28 +25914,28 @@ fn aiur_fn_239( }) } -const INPUT_SIZE_240: usize = 2; -const IN_240: usize = 2; -const OUT_240: usize = 1; -fn aiur_fn_240( - inp: [G; IN_240], +const INPUT_SIZE_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_240], ExecError> { +) -> 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_240] = [__v_0]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_240] = { let __args: [G; IN_240] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -24719,8 +25944,8 @@ fn aiur_fn_240( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_240] = [__v_8]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -24732,28 +25957,28 @@ fn aiur_fn_240( }) } -const INPUT_SIZE_241: usize = 2; -const IN_241: usize = 2; -const OUT_241: usize = 1; -fn aiur_fn_241( - inp: [G; IN_241], +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_241], 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_241] = [__v_0]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_241] = { let __args: [G; IN_241] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -24764,8 +25989,8 @@ fn aiur_fn_241( let __v_10: G = __loaded[5]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_241] = [__v_10]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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); }, _ => { @@ -24777,28 +26002,28 @@ fn aiur_fn_241( }) } -const INPUT_SIZE_242: usize = 2; -const IN_242: usize = 2; -const OUT_242: usize = 1; -fn aiur_fn_242( - inp: [G; IN_242], +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_242], ExecError> { +) -> 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_242] = [__v_0]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_242] = { let __args: [G; IN_242] = [__v_0, __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 __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]; @@ -24813,8 +26038,8 @@ fn aiur_fn_242( let __v_14: G = __loaded[9]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_242] = [__v_14]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -26048,6 +27273,26 @@ pub(crate) fn execute_generated( 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 c124d03f2..52f6ee7d0 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs @@ -42,6 +42,15 @@ pub struct JoinTree<'a> { 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 @@ -56,6 +65,7 @@ pub struct JoinAdvice<'a> { 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 @@ -80,6 +90,18 @@ pub fn decode_join_trees(blob: &[u8]) -> Result>, String> { }) } +/// 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>, 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, @@ -222,7 +244,7 @@ pub fn verifier_io_buffer(proof: &[u8], vk: &[u8], claims: &[u8]) -> IOBuffer { io } -/// Build `join_two`'s six-channel IO advice buffer. +/// Build the flat/structural join entrypoints' seven-channel IO advice buffer. /// /// Layout (the circuit binds every digest-addressed blob before decoding): /// @@ -231,7 +253,8 @@ pub fn verifier_io_buffer(proof: &[u8], vk: &[u8], claims: &[u8]) -> IOBuffer { /// * 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 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() }; @@ -255,6 +278,14 @@ pub fn join_io_buffer(advice: &JoinAdvice<'_>) -> IOBuffer { 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 } @@ -300,6 +331,7 @@ mod tests { } 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], @@ -308,6 +340,7 @@ mod tests { allowed: &[10], preimages: &preimages, trees: &trees, + paths: &paths, }; let io = join_io_buffer(&advice); @@ -324,6 +357,7 @@ mod tests { 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)); } @@ -345,8 +379,13 @@ mod tests { 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()); } } From 6ea4bbac38a5f5ebedb2f5839ceab9620a0a05ed Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Fri, 28 Aug 2026 06:39:30 -0400 Subject: [PATCH 03/44] feat: support single-shard aggregate roots --- Ix/Cli/AggregateCmd.lean | 64 ++++++++++++---------- Ix/Cli/CheckCmd.lean | 47 ++++++++++++++++- Ix/Cli/VerifyCmd.lean | 105 ++++++++++++++++++++++--------------- Tests/MultiStark.lean | 58 ++++++++++++++++++-- crates/ixon/src/proof.rs | 21 ++++++-- crates/kernel/src/claim.rs | 8 +-- crates/kernel/src/shard.rs | 77 +++++++++++++++++++++++---- 7 files changed, 285 insertions(+), 95 deletions(-) diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index e1f54877c..ec7f7ee2f 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -1,12 +1,13 @@ /- `ix aggregate --ixe E --ixes M ...` - Bind persisted shard proof wrappers to every shard in a manifest, lift each - IxVM proof into the Multi-STARK recursion system, then execute/prove binary - joins in the manifest's bisection-tree order. Small joins use flat canonical - subjects; joins above `--structural-above` use an O(1) root-of-roots subject - fold plus assumption-membership paths. The final persisted wrapper carries - the aggregate `CheckEnv` claim and recursive proof bytes. + Bind persisted shard proof wrappers to every nonempty shard in a manifest, + lift each IxVM proof into the Multi-STARK recursion system, then execute/prove + any binary joins in the manifest's bisection-tree order. Small joins use flat + canonical subjects; joins above `--structural-above` use an O(1) + root-of-roots subject fold plus assumption-membership paths. The final + persisted wrapper carries the aggregate `CheckEnv` claim and recursive proof + bytes. This first host driver is intentionally serial and cache-free. Its slot model and content-addressed inputs make parallel scheduling and resumable @@ -95,7 +96,8 @@ private def compileToplevel (label : String) | .error e => return Except.error s!"{label} compilation failed: {e}" | .ok compiled => return Except.ok compiled -private def printPlan (plan : Array ScheduledFold) (structuralAbove : Nat) : IO Unit := do +private def printPlan (plan : Array ScheduledFold) (shardIds : Array Nat) + (structuralAbove : Nat) : IO Unit := do let lifts := plan.countP fun item => match item.op with | .leaf _ => true | .join _ _ => false @@ -105,7 +107,8 @@ private def printPlan (plan : Array ScheduledFold) (structuralAbove : Nat) : IO for (item, slot) in plan.mapIdx fun slot item => (item, slot) do match item.op with | .leaf shard => - IO.println s!" slot {slot}: lift shard {shard} ({item.subjectCount} subjects)" + let originalShard := (shardIds[shard]?).getD shard + IO.println s!" slot {slot}: lift shard {originalShard} ({item.subjectCount} subjects)" | .join left right => let mode := if item.structural then "structural" else "flat" IO.println s!" slot {slot}: {mode} join slots {left}, {right} \ @@ -119,28 +122,27 @@ def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do p.printError "error: aggregate requires --ixes " return 1 - let view ← match Ix.Cli.CheckCmd.parseIxesManifest + 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 view.shards) then return 1 - if view.shards.size < 2 then - IO.eprintln "aggregate currently requires at least two shards (single-shard lift packaging is not yet exposed)" - return 1 - let shardCounts := Ix.Cli.CheckCmd.ownedConstCountsForShards env view.shards - if shardCounts.any (· == 0) then - IO.eprintln "aggregate currently requires non-empty shards; regenerate or prune empty manifest leaves" - return 1 + 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 plan ← match schedulePlan view.aggregationTree.foldPlan shardCounts structuralAbove with | .error e => IO.eprintln e; return 1 | .ok plan => pure plan - printPlan plan structuralAbove + printPlan plan view.shardIds structuralAbove if p.hasFlag "plan-only" then return 0 let proofHexes := (p.variableArgsAs! String).toList @@ -153,12 +155,14 @@ def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do 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 {shard}: {e}"; return 1 + | .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}" + IO.eprintln s!"duplicate reconstructed shard claim digest {digest} \ + (manifest shard {originalShard})" return 1 digestToShard := digestToShard.insert digest shard prepared := prepared.push item @@ -180,11 +184,12 @@ def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do 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 {shard}" + 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 {shard}" + 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 @@ -215,14 +220,15 @@ def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do for (item, slotIdx) in plan.mapIdx fun slotIdx item => (item, slotIdx) do match item.op with | .leaf shard => + let originalShard := (view.shardIds[shard]?).getD shard let some wrapper := proofsByShard.get? shard | do - IO.eprintln s!"internal: no proof for shard {shard}" + IO.eprintln s!"internal: no proof for shard {originalShard}" return 1 let some preparedShard := prepared[shard]? | do - IO.eprintln s!"internal: no statement for shard {shard}" + IO.eprintln s!"internal: no statement for shard {originalShard}" return 1 if preparedShard.statement.subjectCount != item.subjectCount then - IO.eprintln s!"internal: shard {shard} has {preparedShard.statement.subjectCount} \ + IO.eprintln s!"internal: shard {originalShard} has {preparedShard.statement.subjectCount} \ reconstructed subjects, but the schedule records {item.subjectCount}" return 1 let claimBytes := Ix.Claim.ser preparedShard.claim @@ -232,12 +238,12 @@ def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do let innerProof := Aiur.Proof.ofBytes wrapper.proof match ixvmSystem.verify innerClaim innerProof with | .error e => - IO.eprintln s!"shard {shard} proof fails native verification: {e}" + IO.eprintln s!"shard {originalShard} proof fails native verification: {e}" return 1 | .ok () => pure () let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] let pubInput := MultiStark.verifierPubInput ixvmVk innerClaimsBytes - IO.println s!"[aggregate] lifting shard {shard} into slot {slotIdx}" + IO.println s!"[aggregate] lifting shard {originalShard} into slot {slotIdx}" (← IO.getStdout).flush let (outerClaim, proof) := recursionSystem.proveMultiStark liftIdx pubInput wrapper.proof ixvmVk innerClaimsBytes @@ -334,7 +340,7 @@ end Ix.Cli.AggregateCmd open Ix.Cli.AggregateCmd in def aggregateCmd : Cli.Cmd := `[Cli| aggregate VIA runAggregateCmd; - "Lift shard proofs and fold them into one recursive aggregate along a `.ixes` bisection tree" + "Lift shard proofs and fold multi-shard manifests into one recursive aggregate" FLAGS: "ixe" : String; "Path to the serialized environment whose shards were proven." @@ -343,7 +349,7 @@ def aggregateCmd : Cli.Cmd := `[Cli| "structural-above" : Nat; "Use structural joins when a node contains more than N subject leaves (default 4096; 0 means every join)." ARGS: - ...proofs : String; "Persisted shard-proof wrapper addresses, in any order (exactly one per shard unless --plan-only)." + ...proofs : String; "Persisted shard-proof wrapper addresses, in any order (exactly one per nonempty shard unless --plan-only)." ] end diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index d26603d92..58dec519b 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -471,10 +471,25 @@ where 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 @@ -545,7 +560,7 @@ def parseIxesManifest (bytes : ByteArray) : Except String IxesManifestView := let (buffer, position) ← get if position != buffer.size then throw s!"ixes: {buffer.size - position} trailing bytes after aggregation tree" - pure { shards, aggregationTree := 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 @@ -595,6 +610,36 @@ def ownedConstCountsForShards (ixonEnv : Ixon.Env) 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. -/ diff --git a/Ix/Cli/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean index a6490adfb..2e163eba5 100644 --- a/Ix/Cli/VerifyCmd.lean +++ b/Ix/Cli/VerifyCmd.lean @@ -83,18 +83,22 @@ def buildBackend : IO (Except String (Aiur.AiurSystem × Aiur.CompiledToplevel)) structure AggregateBackend where system : Aiur.AiurSystem + ixvmVk : ByteArray + verifyClaimIdx : Aiur.Bytecode.FunIdx + liftIdx : Aiur.Bytecode.FunIdx flatJoinIdx : Aiur.Bytecode.FunIdx structuralJoinIdx : Aiur.Bytecode.FunIdx allowed : ByteArray inductive AggregateRootKind where + | lift | flat | structural deriving BEq, Repr structure ExpectedAggregate where claim : Ix.Claim - kind : AggregateRootKind + kinds : Array AggregateRootKind /-- Build the two deterministic systems whose identities are committed by an aggregate root: the IxVM vk and the combined lift/join recursion vk. -/ @@ -118,11 +122,15 @@ private def buildAggregateBackend : commitmentParameters friParameters let recursionSystem := Aiur.AiurSystem.build recursionCompiled.bytecode commitmentParameters friParameters + let ixvmVk := ixvmSystem.vkBytes let recursionVk := recursionSystem.vkBytes - let allowed := MultiStark.allowedBlob ixvmSystem.vkBytes verifyIdx + let allowed := MultiStark.allowedBlob ixvmVk verifyIdx recursionVk liftIdx joinIdx structuralJoinIdx return .ok { system := recursionSystem + ixvmVk + verifyClaimIdx := verifyIdx + liftIdx flatJoinIdx := joinIdx structuralJoinIdx allowed @@ -134,16 +142,13 @@ private def shardStatement (env : Ixon.Env) (blocks : Array Address) : let (claim, _, trees) ← IxVM.ClaimHarness.shardCheckEnvClaim env owned MultiStark.CheckEnvTrees.ofClaim claim trees -/-- Reproduce the hybrid flat/structural statement fold from the manifest. -The threshold schedule is shared with `ix aggregate`; no proof data is needed. -/ -private def expectedFromManifest (env : Ixon.Env) +/-- Reproduce the lift/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 (MultiStark.CheckEnvTrees × AggregateRootKind) := do - if view.shards.size < 2 then - throw "aggregate verification requires a manifest with at least two shards" - let counts := Ix.Cli.CheckCmd.ownedConstCountsForShards env view.shards - if counts.any (· == 0) then - throw "aggregate verification requires non-empty shards" + let (view, counts) ← view.pruneEmpty env let plan ← Ix.Cli.AggregateCmd.schedulePlan view.aggregationTree.foldPlan counts structuralAbove let mut slots : Array MultiStark.CheckEnvTrees := #[] @@ -164,10 +169,29 @@ private def expectedFromManifest (env : Ixon.Env) leftStatement.join rightStatement let some root := slots.back? | throw "aggregate manifest produced no root" let some rootPlan := plan.back? | throw "aggregate manifest produced no root slot" - pure (root, if rootPlan.structural then .structural else .flat) + let kind := match rootPlan.op with + | .leaf _ => AggregateRootKind.lift + | .join _ _ => if rootPlan.structural then .structural else .flat + pure (root, kind) -private def verifyAggregateProof (recursionSystem : Aiur.AiurSystem) - (flatJoinIdx structuralJoinIdx : Aiur.Bytecode.FunIdx) (allowed : ByteArray) +/-- Reconstruct the exact outer claim of a single-shard lift from the bundled +`CheckEnv` statement. This is the verification-side inverse of the leaf arm in +`ix aggregate`: the wrapper claim determines the nested IxVM `verify_claim`, +whose serialized singleton list determines the lift public input. -/ +def aggregateLiftOuterClaim (ixvmVk : ByteArray) + (verifyClaimIdx liftIdx : Aiur.Bytecode.FunIdx) (claim : Ix.Claim) : Array Aiur.G := + let claimBytes := Ix.Claim.ser claim + let verifyInput := IxVM.ClaimHarness.packedDigestKey (Address.blake3 claimBytes) + let innerClaim := Aiur.buildClaim verifyClaimIdx verifyInput #[] + let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] + Aiur.buildClaim liftIdx (MultiStark.verifierPubInput ixvmVk innerClaimsBytes) #[] + +private def aggregateRootKindLabel : AggregateRootKind → String + | .lift => "lift" + | .flat => "flat" + | .structural => "structural" + +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 @@ -179,32 +203,28 @@ private def verifyAggregateProof (recursionSystem : Aiur.AiurSystem) IO.eprintln s!"error: aggregate claim {wrapper.claim} does not match expected {expected.claim}" return 1 | none => pure () - let claimBytes := Ix.Claim.ser wrapper.claim - let pubInput := MultiStark.joinPubInput allowed claimBytes let proof := Aiur.Proof.ofBytes wrapper.proof - let verifyAt (idx : Aiur.Bytecode.FunIdx) := - recursionSystem.verify (Aiur.buildClaim idx pubInput #[]) proof - let result : Except String AggregateRootKind := match expected? with - | some expected => - let idx := match expected.kind with - | .flat => flatJoinIdx - | .structural => structuralJoinIdx - (verifyAt idx).map fun _ => expected.kind - | none => - match verifyAt flatJoinIdx with - | .ok () => .ok .flat - | .error flatError => match verifyAt structuralJoinIdx with - | .ok () => .ok .structural - | .error structuralError => .error - s!"flat join: {flatError}; structural join: {structuralError}" - match result with - | .error e => - IO.eprintln s!"error: aggregate verification failed: {e}" - return 1 - | .ok kind => - let label := match kind with | .flat => "flat" | .structural => "structural" - IO.println s!"ok: {label} aggregate proof {proofAddr} verifies {wrapper.claim}" - return 0 + let claimBytes := Ix.Claim.ser wrapper.claim + let joinPubInput := MultiStark.joinPubInput backend.allowed claimBytes + let outerClaim : AggregateRootKind → Array Aiur.G + | .lift => aggregateLiftOuterClaim backend.ixvmVk backend.verifyClaimIdx + backend.liftIdx wrapper.claim + | .flat => Aiur.buildClaim backend.flatJoinIdx joinPubInput #[] + | .structural => Aiur.buildClaim backend.structuralJoinIdx joinPubInput #[] + let kinds := expected?.map (·.kinds) |>.getD + #[.lift, .flat, .structural] + let mut errors : Array String := #[] + for kind in kinds do + match backend.system.verify (outerClaim kind) proof with + | .ok () => + IO.println s!"ok: {aggregateRootKindLabel kind} aggregate proof \ + {proofAddr} verifies {wrapper.claim}" + return 0 + | .error e => + errors := errors.push s!"{aggregateRootKindLabel kind}: {e}" + IO.eprintln s!"error: aggregate verification failed: \ + {String.intercalate "; " errors.toList}" + return 1 /-- Shard-aware verification (parity with `check`/`prove`): - `--shard K`, no proof: print shard K's reconstructed `CheckEnv` claim @@ -297,7 +317,7 @@ def runVerifyCmd (p : Cli.Parsed) : IO UInt32 := do return 1 pure (some { claim := .checkEnv expectedTree.root none - kind := .flat + kinds := #[.lift, .flat] }) | some ixePath, some manifestPath => let env ← match Ixon.deEnvAnon (← IO.FS.readBinFile ixePath) with @@ -315,7 +335,7 @@ def runVerifyCmd (p : Cli.Parsed) : IO UInt32 := do IO.eprintln s!"error: expected aggregate root retains assumptions \ {statement.assumptions.map (·.root)}" return 1 - pure (some { claim := statement.claim, kind }) + pure (some { claim := statement.claim, kinds := #[kind] }) | none, some _ => unreachable! let backend ← match ← buildAggregateBackend with | .error e => IO.eprintln e; return 1 @@ -323,8 +343,7 @@ def runVerifyCmd (p : Cli.Parsed) : IO UInt32 := do let mut rc : UInt32 := 0 for hex in proofs do let proofAddr ← addrOfHex! "aggregate proof" hex - if (← verifyAggregateProof backend.system backend.flatJoinIdx - backend.structuralJoinIdx backend.allowed expected? proofAddr) != 0 then + 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 @@ -354,7 +373,7 @@ def verifyCmd : Cli.Cmd := `[Cli| "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). 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 proof arguments as aggregate-first recursive roots. With --ixe alone, expects an all-flat canonical root; add --ixes for hybrid structural roots." + "aggregate"; "Interpret proofs as aggregate-first roots. With --ixe alone, accepts a single lift or all-flat canonical root; add --ixes for the exact lift/flat/structural manifest root." "structural-above" : Nat; "For --aggregate + --ixes, reproduce structural joins above N subject leaves (default 4096; must match proving)." ARGS: diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index 942e0f69b..e375a4d35 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -7,6 +7,7 @@ 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 @@ -259,11 +260,25 @@ private def bytesAsGs (bytes : ByteArray) : Array Aiur.G := private def u32le4 (n : Nat) : Array UInt8 := (Array.range 4).map fun i => UInt8.ofNat ((n >>> (8 * i)) % 256) -private def minimalIxes (treeTail : Array UInt8) : ByteArray := - let shard := fun id => u32le4 id ++ Array.replicate 24 0 ++ #[0] ++ - u32le4 0 ++ u32le4 0 +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 2 ++ shard 0 ++ shard 1 ++ treeTail⟩ + 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 canonicalTree (leaves : Array Address) : Ix.AssumptionTree := (Ix.AssumptionTree.canonical leaves).get! @@ -328,6 +343,12 @@ def joinSmokeSuite : IO UInt32 := do let recursionVk := childSystem.vkBytes let allowed := MultiStark.allowedBlob fakeIxvmVk verifyIdx recursionVk liftIdx childJoinIdx childStructuralJoinIdx + let reconstructedLiftClaim := + Ix.Cli.VerifyCmd.aggregateLiftOuterClaim fakeIxvmVk verifyIdx liftIdx + leftStatement.claim + let liftClaimReconstruction := reconstructedLiftClaim == leftOuter + let reconstructedLiftVerifies := + childSystem.verify reconstructedLiftClaim leftProof let outputClaimBytes := Ix.Claim.ser outputStatement.claim let pubInput := MultiStark.joinPubInput allowed outputClaimBytes @@ -600,6 +621,27 @@ def joinSmokeSuite : IO UInt32 := do 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 singleManifestLiftRoot : Bool := match singleManifest with + | .ok view => match Ix.Cli.VerifyCmd.expectedFromManifest singleEnv view 0 with + | .ok (statement, .lift) => + statement.claim == .checkEnv (canonicalTree #[singleAddr]).root none + | _ => false + | .error _ => false let mixedScheduleCorrect : Bool := match Ix.Cli.AggregateCmd.schedulePlan manifestPlan #[2, 2, 1] 4 with | .ok scheduled => @@ -615,9 +657,17 @@ def joinSmokeSuite : IO UInt32 := do 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 folds to a lift root" singleManifestLiftRoot, 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, 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/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/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 { + 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, + ) -> Option { 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 { + 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 = 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::(); + 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, 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![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(); From ccf17ceb2b2be964915cfed159329e7b5ae59949 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Fri, 28 Aug 2026 08:01:49 -0400 Subject: [PATCH 04/44] feat: audit aggregate recursion activation and parameters Add the deterministic lift/flat/structural activation matrix and keep dummy calls deferred. Split aggregate recursion commitment/FRI configuration from IxVM defaults, share it between proving and verification, and pin the future cache encoding without changing active protocol parameters. --- Ix/Cli/AggregateCmd.lean | 14 +- Ix/Cli/VerifyCmd.lean | 17 +- Ix/MultiStark.lean | 40 +++ Tests/Main.lean | 7 + Tests/MultiStark.lean | 64 +++- Tests/MultiStarkActivation.lean | 523 ++++++++++++++++++++++++++++++++ 6 files changed, 655 insertions(+), 10 deletions(-) create mode 100644 Tests/MultiStarkActivation.lean diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index ec7f7ee2f..04bb32658 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -114,7 +114,12 @@ private def printPlan (plan : Array ScheduledFold) (shardIds : Array Nat) IO.println s!" slot {slot}: {mode} join slots {left}, {right} \ ({item.subjectCount} subjects)" -def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do +/-- 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 " return 1 @@ -209,8 +214,8 @@ def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do let structuralJoinIdx := recursionCompiled.getFuncIdx `join_two_structural |>.get! let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode Aiur.defaultCommitmentParameters Aiur.defaultFriParameters - let recursionSystem := Aiur.AiurSystem.build recursionCompiled.bytecode - Aiur.defaultCommitmentParameters Aiur.defaultFriParameters + let recursionSystem := MultiStark.buildRecursionSystem recursionCompiled.bytecode + recursionParameters let ixvmVk := ixvmSystem.vkBytes let recursionVk := recursionSystem.vkBytes let allowed := MultiStark.allowedBlob ixvmVk verifyIdx recursionVk liftIdx @@ -335,6 +340,9 @@ def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := do 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 diff --git a/Ix/Cli/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean index 2e163eba5..b48f2442a 100644 --- a/Ix/Cli/VerifyCmd.lean +++ b/Ix/Cli/VerifyCmd.lean @@ -102,7 +102,8 @@ structure ExpectedAggregate where /-- Build the two deterministic systems whose identities are committed by an aggregate root: the IxVM vk and the combined lift/join recursion vk. -/ -private def buildAggregateBackend : +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}" @@ -120,8 +121,8 @@ private def buildAggregateBackend : let structuralJoinIdx := recursionCompiled.getFuncIdx `join_two_structural |>.get! let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode commitmentParameters friParameters - let recursionSystem := Aiur.AiurSystem.build recursionCompiled.bytecode - commitmentParameters friParameters + let recursionSystem := MultiStark.buildRecursionSystem recursionCompiled.bytecode + recursionParameters let ixvmVk := ixvmSystem.vkBytes let recursionVk := recursionSystem.vkBytes let allowed := MultiStark.allowedBlob ixvmVk verifyIdx @@ -293,7 +294,10 @@ 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 @@ -337,7 +341,7 @@ def runVerifyCmd (p : Cli.Parsed) : IO UInt32 := do return 1 pure (some { claim := statement.claim, kinds := #[kind] }) | none, some _ => unreachable! - let backend ← match ← buildAggregateBackend with + let backend ← match ← buildAggregateBackend recursionParameters with | .error e => IO.eprintln e; return 1 | .ok backend => pure backend let mut rc : UInt32 := 0 @@ -362,6 +366,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 diff --git a/Ix/MultiStark.lean b/Ix/MultiStark.lean index ba5be06fa..47f02a47d 100644 --- a/Ix/MultiStark.lean +++ b/Ix/MultiStark.lean @@ -132,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`. -/ diff --git a/Tests/Main.lean b/Tests/Main.lean index b96e2735e..15e7eb94a 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -53,6 +53,7 @@ import Tests.Ix.CondenseM import Tests.FFI import Tests.Keccak import Tests.MultiStark +import Tests.MultiStarkActivation import Tests.Cli import Tests.ShardMap import Tests.Ix.EnvBody @@ -318,6 +319,12 @@ def main (args : List String) : IO UInt32 := do if args.contains "cli" then return ← Tests.Cli.suite + -- Section 13 WP-D diagnostic: keep the 98-case, twice-executed activation + -- matrix out of the default primary suite while making its gate explicit and + -- independent of the large compiled Lean environment used by ignored tests. + if args.contains "aggregate-activation" then + return ← Tests.MultiStark.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 e375a4d35..74bac7143 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -241,13 +241,33 @@ 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 := ⟦ - pub fn fake_verify_claim(_digest: [G; 8]) { () } - pub fn fake_lift(_system_digest: [G; 8], _claims_digest: [G; 8]) { () } + 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]); () @@ -296,6 +316,40 @@ def joinSmokeSuite : IO UInt32 := do | .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! @@ -653,6 +707,12 @@ def joinSmokeSuite : IO UInt32 := do | .error _ => 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 "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, diff --git a/Tests/MultiStarkActivation.lean b/Tests/MultiStarkActivation.lean new file mode 100644 index 000000000..ec685a067 --- /dev/null +++ b/Tests/MultiStarkActivation.lean @@ -0,0 +1,523 @@ +module + +public import Tests.MultiStark + +/-! +# Aggregate recursion activation audit + +WP-D from `plans/aggregate-first-pipeline.md` asks for an input-shape audit of +the production lift, flat-join, and structural-join entrypoints before any +future static terminal circuit relies on an input-independent activation set. + +This runner deliberately stays separate from the normal aggregate smoke suite. +It executes a deterministic 98-case matrix twice, compares every returned +per-circuit query count, and emits a Markdown report of circuits inactive in at +least one case. It does not add dummy calls; that policy remains deferred until +a static terminal is selected. +-/ + +public section + +open Aiur + +namespace Tests.MultiStark +namespace ActivationAudit + +inductive Height where + | short + | tall + deriving BEq, Repr + +private def Height.label : Height → String + | .short => "short" + | .tall => "tall" + +inductive ChildKind where + | lift + | flat + | structural + deriving BEq, Repr + +private def ChildKind.label : ChildKind → String + | .lift => "lift" + | .flat => "flat" + | .structural => "structural" + +inductive Disposition where + | discharge + | carry + deriving BEq, Repr + +private def Disposition.label : Disposition → String + | .discharge => "discharge" + | .carry => "carry" + +inductive Entrypoint where + | lift + | flat + | structural + deriving BEq, Repr + +private def Entrypoint.label : Entrypoint → String + | .lift => "lift" + | .flat => "flat" + | .structural => "structural" + +private inductive JoinKind where + | flat + | structural + +private def JoinKind.entrypoint : JoinKind → Entrypoint + | .flat => .flat + | .structural => .structural + +private def JoinKind.label (kind : JoinKind) : String := + kind.entrypoint.label + +/-- Cheap parameters are sufficient here: the audit studies which verifier +circuits execute, not soundness calibration or proof size. -/ +private def auditFri : Aiur.FriParameters := + { logFinalPolyLen := 0, maxLogArity := 1, numQueries := 1, + commitProofOfWorkBits := 0, queryProofOfWorkBits := 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 + lift : Aiur.Bytecode.FunIdx + flat : Aiur.Bytecode.FunIdx + structural : Aiur.Bytecode.FunIdx + +private structure HeightConfig where + height : Height + fakeIxvmVk : ByteArray + allowed : ByteArray + probeRows : Nat + +/-- Find a tiny fake IxVM key whose own digest and resulting allowed-blob +digest select the same branch of `activation_vary_height`. The search has +roughly 1/4 success probability per candidate for either requested branch. -/ +private def findFakeIxvmVk (childVk : ByteArray) (indices : Indices) + (height : Height) : Except String ByteArray := + let wantShort := height == .short + let candidate? := (Array.range 4096).find? fun n => + let candidate : ByteArray := ⟨Tests.MultiStark.u64le n⟩ + let allowed := MultiStark.allowedBlob candidate indices.verify childVk + indices.lift indices.flat indices.structural + digestSelectsShort (MultiStark.digestGs candidate) == wantShort && + digestSelectsShort (MultiStark.digestGs allowed) == wantShort + match candidate? with + | some n => .ok ⟨Tests.MultiStark.u64le n⟩ + | none => .error s!"activation audit: no {height.label} digest selector found" + +private def heightProbeRows (compiled : Aiur.CompiledToplevel) + (verifyIdx probeIdx : Aiur.Bytecode.FunIdx) (fakeIxvmVk : ByteArray) : + Except String Nat := do + let (_, _, counts) ← compiled.bytecode.execute verifyIdx + (MultiStark.digestGs fakeIxvmVk) default + let some count := counts[probeIdx]? + | throw s!"activation audit: missing height-probe query count {probeIdx}" + pure count.uniqueRows + +private def prepareHeightConfig (compiled : Aiur.CompiledToplevel) + (childVk : ByteArray) (indices : Indices) (probeIdx : Aiur.Bytecode.FunIdx) + (height : Height) : Except String HeightConfig := do + let fakeIxvmVk ← findFakeIxvmVk childVk indices height + let allowed := MultiStark.allowedBlob fakeIxvmVk indices.verify childVk + indices.lift indices.flat indices.structural + let probeRows ← heightProbeRows compiled indices.verify probeIdx fakeIxvmVk + pure { height, fakeIxvmVk, allowed, probeRows } + +private structure PreparedChild where + proofBytes : ByteArray + outerClaimsBytes : ByteArray + preimages : Array ByteArray + +private def prepareChild (system : Aiur.AiurSystem) (indices : Indices) + (config : HeightConfig) (kind : ChildKind) + (statement : MultiStark.CheckEnvTrees) : PreparedChild := + let claimBytes := Ix.Claim.ser statement.claim + match kind with + | .lift => + let innerClaim := Aiur.buildClaim indices.verify + (MultiStark.digestGs claimBytes) #[] + let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] + let input := MultiStark.verifierPubInput config.fakeIxvmVk innerClaimsBytes + let (outer, proof, _) := system.prove indices.lift input default + { proofBytes := proof.toBytes + outerClaimsBytes := MultiStark.serializeClaims #[outer] + preimages := #[innerClaimsBytes, claimBytes] } + | .flat | .structural => + let idx := match kind with + | .flat => indices.flat + | .structural => indices.structural + | .lift => unreachable! + let input := MultiStark.joinPubInput config.allowed claimBytes + let (outer, proof, _) := system.prove idx input default + { proofBytes := proof.toBytes + outerClaimsBytes := MultiStark.serializeClaims #[outer] + preimages := #[claimBytes] } + +private structure JoinCase where + label : String + allowed : ByteArray + left : MultiStark.CheckEnvTrees + right : MultiStark.CheckEnvTrees + leftChild : PreparedChild + rightChild : PreparedChild + +private def assumptionLabel (present : Bool) : String := + if present then "some" else "none" + +private def selectStatement (withoutAsm discharge carry : + MultiStark.CheckEnvTrees) (present : Bool) + (disposition : Disposition) : MultiStark.CheckEnvTrees := + if !present then withoutAsm + else match disposition with + | .discharge => discharge + | .carry => carry + +/-- Build the 48 join inputs shared by the flat and structural entrypoints: + +`2 heights × 2 dispositions × 2 left-asm shapes × 2 right-asm shapes + × 3 left-child kinds`. + +The right child remains a lift. Both child positions call the same decoder, so +varying one side covers all three decoder arms while retaining a mixed-shape +case for the flat and structural child kinds. -/ +private def prepareJoinCases (system : Aiur.AiurSystem) (indices : Indices) + (configs : Array HeightConfig) : Array JoinCase := Id.run do + let a := Address.blake3 "activation-subject-left".toUTF8 + let b := Address.blake3 "activation-subject-right".toUTF8 + let c := Address.blake3 "activation-carry-left".toUTF8 + let d := Address.blake3 "activation-carry-right".toUTF8 + let leftSubjects := canonicalTree #[a] + let rightSubjects := canonicalTree #[b] + let leftNone : MultiStark.CheckEnvTrees := + { subjects := leftSubjects, assumptions := none } + let leftDischarge : MultiStark.CheckEnvTrees := + { subjects := leftSubjects, assumptions := some (canonicalTree #[b]) } + let leftCarry : MultiStark.CheckEnvTrees := + { subjects := leftSubjects, assumptions := some (canonicalTree #[c]) } + let rightNone : MultiStark.CheckEnvTrees := + { subjects := rightSubjects, assumptions := none } + let rightDischarge : MultiStark.CheckEnvTrees := + { subjects := rightSubjects, assumptions := some (canonicalTree #[a]) } + let rightCarry : MultiStark.CheckEnvTrees := + { subjects := rightSubjects, assumptions := some (canonicalTree #[d]) } + let mut cases : Array JoinCase := #[] + for config in configs do + for disposition in #[Disposition.discharge, .carry] do + for leftAsm in #[false, true] do + for rightAsm in #[false, true] do + let left := selectStatement leftNone leftDischarge leftCarry + leftAsm disposition + let right := selectStatement rightNone rightDischarge rightCarry + rightAsm disposition + let rightChild := prepareChild system indices config .lift right + for childKind in #[ChildKind.lift, .flat, .structural] do + let leftChild := prepareChild system indices config childKind left + cases := cases.push { + label := s!"height={config.height.label},left-asm={assumptionLabel leftAsm},\ + right-asm={assumptionLabel rightAsm},disposition={disposition.label},\ + left-child={childKind.label},right-child=lift" + allowed := config.allowed + left + right + leftChild + rightChild + } + return cases + +private structure Sample where + label : String + entrypoint : Entrypoint + queryCounts : Array Aiur.QueryCount + +private def runLift (compiled : Aiur.CompiledToplevel) + (childSystem : Aiur.AiurSystem) (childVk : ByteArray) (indices : Indices) + (productionLiftIdx : Aiur.Bytecode.FunIdx) (config : HeightConfig) : + Except String Sample := do + let input := MultiStark.digestGs config.fakeIxvmVk + let (innerClaim, proof, _) := childSystem.prove indices.verify input default + let claimBytes := MultiStark.serializeClaims #[innerClaim] + let pubInput := MultiStark.verifierPubInput childVk claimBytes + let (_, queryCounts) ← compiled.bytecode.executeMultiStark productionLiftIdx + pubInput proof.toBytes childVk claimBytes + pure { + label := s!"lift/height={config.height.label}" + entrypoint := .lift + queryCounts + } + +private def runJoinWithVk (compiled : Aiur.CompiledToplevel) + (childVk : ByteArray) (flatIdx structuralIdx : Aiur.Bytecode.FunIdx) + (kind : JoinKind) (case : JoinCase) : Except String Sample := do + let output := match kind with + | .flat => case.left.join case.right + | .structural => case.left.joinStructural case.right + let idx := match kind with + | .flat => flatIdx + | .structural => structuralIdx + let trees := match kind with + | .flat => MultiStark.CheckEnvTrees.adviceTrees case.left case.right output + | .structural => + MultiStark.CheckEnvTrees.structuralAdviceTrees case.left case.right output + let paths := match kind with + | .flat => #[] + | .structural => + MultiStark.CheckEnvTrees.structuralPathAdvice case.left case.right output + let outputBytes := Ix.Claim.ser output.claim + let pubInput := MultiStark.joinPubInput case.allowed outputBytes + let preimagesBlob := MultiStark.joinPreimagesBlob + (case.leftChild.preimages ++ case.rightChild.preimages) + let (_, queryCounts) ← match compiled.bytecode.executeMultiStarkJoin idx + pubInput case.leftChild.proofBytes case.rightChild.proofBytes childVk + case.leftChild.outerClaimsBytes case.rightChild.outerClaimsBytes outputBytes + case.allowed preimagesBlob (MultiStark.joinTreesBlob trees) + (MultiStark.joinPathsBlob paths) with + | .ok result => pure result + | .error e => throw s!"{kind.label}/{case.label}: {e}" + pure { + label := s!"{kind.label}/{case.label}" + entrypoint := kind.entrypoint + queryCounts + } + +private def collect (compiled : Aiur.CompiledToplevel) + (childSystem : Aiur.AiurSystem) (childVk : ByteArray) (indices : Indices) + (productionLiftIdx flatIdx structuralIdx : Aiur.Bytecode.FunIdx) + (configs : Array HeightConfig) (cases : Array JoinCase) : + Except String (Array Sample) := do + let mut samples : Array Sample := #[] + for config in configs do + samples := samples.push (← runLift compiled childSystem childVk indices + productionLiftIdx config) + for case in cases do + samples := samples.push (← runJoinWithVk compiled childVk flatIdx + structuralIdx .flat case) + for case in cases do + samples := samples.push (← runJoinWithVk compiled childVk flatIdx + structuralIdx .structural 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.entrypoint == b.entrypoint && + 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 + } + return 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 entrySamples (samples : Array Sample) (entrypoint : Entrypoint) : + Array Sample := + samples.filter fun sample => sample.entrypoint == entrypoint + +private def Cell.render (c : Cell) : String := + if c.active == 0 then s!"0/{c.total}" + else s!"{c.active}/{c.total} ({c.minActiveRows}..{c.maxActiveRows})" + +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 liftSamples := entrySamples samples .lift + let flatSamples := entrySamples samples .flat + let structuralSamples := entrySamples samples .structural + let affected := catalog.filter fun circuit => + let summary := cell samples circuit.queryIdx + summary.active < summary.total + let alwaysActive := catalog.countP fun circuit => + let summary := cell samples circuit.queryIdx + summary.active == summary.total + 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 configRows := configs.map fun config => + s!"| {config.height.label} | {config.probeRows} |" + let circuitRows := affected.map fun circuit => + s!"| `{circuit.name}` | {(cell liftSamples circuit.queryIdx).render} | \ + {(cell flatSamples circuit.queryIdx).render} | \ + {(cell structuralSamples circuit.queryIdx).render} |" + let introduction := #[] + |>.push "# Aggregate recursion activation audit" + |>.push "" + |>.push s!"- Matrix signature: `{activationSignature samples}`" + |>.push s!"- Accepted executions: {samples.size} \ + ({liftSamples.size} lift, {flatSamples.size} flat, \ + {structuralSamples.size} structural)" + |>.push "- Join axes: assumption root `{none,some}` independently per side; \ + `{discharge,carry}`; left child `{lift,flat,structural}` with a lift on \ + the right; and two child trace heights." + |>.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 | `activation_height_probe` unique rows |" + |>.push "|---|---:|" + let circuitHeader := (introduction ++ configRows) + |>.push "" + |>.push "## Circuits inactive in at least one audited shape" + |>.push "" + |>.push "| Circuit | Lift | Flat join | Structural join |" + |>.push "|---|---:|---:|---:|" + String.intercalate "\n" (circuitHeader ++ circuitRows).toList + +def run : IO UInt32 := do + IO.println "aggregate-activation (98-case matrix, two deterministic passes)…" + let childCompiled ← match Tests.MultiStark.joinChildProgram.compile with + | .error e => IO.eprintln s!"activation child compilation failed: {e}"; return 1 + | .ok compiled => pure compiled + let childSystem := Aiur.AiurSystem.build childCompiled.bytecode + Tests.MultiStark.recCommitParams auditFri + let childVk := childSystem.vkBytes + let some verifyIdx := childCompiled.getFuncIdx `fake_verify_claim | do + IO.eprintln "activation audit: fake_verify_claim entrypoint not found"; return 1 + let some childLiftIdx := childCompiled.getFuncIdx `fake_lift | do + IO.eprintln "activation audit: fake_lift entrypoint not found"; return 1 + let some childFlatIdx := childCompiled.getFuncIdx `fake_join | do + IO.eprintln "activation audit: fake_join entrypoint not found"; return 1 + let some childStructuralIdx := childCompiled.getFuncIdx `fake_struct_join | do + IO.eprintln "activation audit: fake_struct_join 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 + lift := childLiftIdx + flat := childFlatIdx + structural := childStructuralIdx + } + let short ← match prepareHeightConfig childCompiled childVk indices probeIdx .short with + | .error e => IO.eprintln e; return 1 + | .ok config => pure config + let tall ← match prepareHeightConfig childCompiled childVk 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 cases := prepareJoinCases childSystem indices configs + if cases.size != 48 then + IO.eprintln s!"activation audit: expected 48 join cases, built {cases.size}" + return 1 + + let top ← match MultiStark.multiStark 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 productionLiftIdx := compiled.getFuncIdx `verify_multi_stark_proof | do + IO.eprintln "activation audit: production lift entrypoint not found"; return 1 + let some flatIdx := compiled.getFuncIdx `join_two | do + IO.eprintln "activation audit: flat join entrypoint not found"; return 1 + let some structuralIdx := compiled.getFuncIdx `join_two_structural | do + IO.eprintln "activation audit: structural join entrypoint not found"; return 1 + + let first ← match collect compiled childSystem childVk indices + productionLiftIdx flatIdx structuralIdx configs cases with + | .error e => IO.eprintln s!"activation audit pass 1 failed: {e}"; return 1 + | .ok samples => pure samples + let second ← match collect compiled childSystem childVk indices + productionLiftIdx flatIdx structuralIdx configs cases with + | .error e => IO.eprintln s!"activation audit pass 2 failed: {e}"; return 1 + | .ok samples => pure samples + if first.size != 98 then + IO.eprintln s!"activation audit: expected 98 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.MultiStark + +end From 66fb3766b92f6aa5db740c847bf7f2af919f8cf9 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Mon, 24 Aug 2026 06:36:32 -0700 Subject: [PATCH 05/44] aiur: virtual-gas meter + QueryRecordHandle for per-constant cost profiling MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds an execution-time virtual-gas meter to the Aiur runtime: every constrained query touch is priced at its circuit width, and a memo hit replays the callee's recorded span instead of just the touch, so each function-query entry records its standalone cost — the cost as if nothing were memoized, independent of execution order. - querymap: per-map weight/profile fields, a vspans u64 arena, and replay_at/finish methods that maintain the meter for both engines (the interpreter and the codegen'd kernel share them). - execute + codegen: Call/Store/Load/Return sites routed through the new methods; generated fns snapshot record.virt at frame entry (aiur_ixvm.rs / aiur_multi_stark.rs regenerated). - ffi: every ExecuteResult now carries an opaque QueryRecordHandle owning the execution's QueryRecord, inspected from Lean via the rs_aiur_qr_* accessors (fnLen, fnKey, fnMult, fnVspan, memKey). A profile : Bool is plumbed end-to-end (Lean Full wrappers -> externs -> executors -> QueryRecord::new); prove paths never profile. - ix check --profile : appends one " [name]" line per check_const query, the address recovered by dereferencing the Addr argument (last input slot) through memory[32]; names joined via ixonEnv.addrToName on the shard paths. Intended as order-independent per-constant weights for smarter re-sharding. Meters are side-band (multiplicities and outputs untouched): the kernel FFT cost is unchanged (lake exe ix check Nat.add_comm pin exact), native and bytecode-interpreter profile dumps are byte-identical, and the aiur-cross suite passes. --- Ix/Aiur/Semantics/BytecodeFfi.lean | 106 +- Ix/Aiur/Stages/Codegen.lean | 54 +- Ix/Cli/CheckCmd.lean | 128 +- crates/aiur/src/execute.rs | 129 +- crates/aiur/src/querymap.rs | 103 +- crates/aiur/src/synthesis.rs | 2 +- crates/ffi/src/aiur/protocol.rs | 158 +- crates/ffi/src/lean.rs | 4 +- crates/ixvm-codegen/src/aiur_ixvm.rs | 16710 ++++++++-------- crates/ixvm-codegen/src/aiur_ixvm_runner.rs | 11 +- crates/ixvm-codegen/src/aiur_multi_stark.rs | 3579 ++-- .../src/aiur_multi_stark_runner.rs | 3 +- 12 files changed, 11216 insertions(+), 9771 deletions(-) diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index e699b165a..65ff4b7ce 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -75,14 +75,61 @@ structure QueryCount where totalHits : Nat deriving Inhabited +-- =========================================================================== +-- QueryRecordHandle: the execution's Rust-owned `QueryRecord` exposed to +-- Lean as an opaque handle inside every `ExecuteResult`. Lean inspects +-- queries with its higher-level knowledge (fn names via `nameMap`, +-- layouts, addr→name maps) through the accessors below; the record — +-- the dominant RAM consumer of an execution — frees when Lean drops it. +-- =========================================================================== + +private opaque QueryRecordHandleNonempty : NonemptyType +def QueryRecordHandle : Type := QueryRecordHandleNonempty.type +instance : Nonempty QueryRecordHandle := QueryRecordHandleNonempty.property + +namespace QueryRecordHandle + +/-- Number of query entries registered for function `funIdx`. -/ +@[extern "rs_aiur_qr_fn_len"] +opaque fnLen : @& QueryRecordHandle → (funIdx : @& Nat) → Nat + +/-- Input tuple of entry `i` of function `funIdx` (empty when out of + range). Entries are in insertion order; iterate within `fnLen`. -/ +@[extern "rs_aiur_qr_fn_key"] +opaque fnKey : @& QueryRecordHandle → (funIdx i : @& Nat) → Array G + +/-- Multiplicity of entry `i` of function `funIdx`. `0` marks an + unconstrained hint row (or an out-of-range index). -/ +@[extern "rs_aiur_qr_fn_mult"] +opaque fnMult : @& QueryRecordHandle → (funIdx i : @& Nat) → Nat + +/-- Recorded virtual-gas span of entry `i` of function `funIdx` — the + entry's standalone cost, with memo hits replaying the callee's + recorded span. `0` unless the execution ran with `profile := true` + (the `Full` execution wrappers' trailing flag). -/ +@[extern "rs_aiur_qr_fn_vspan"] +opaque fnVspan : @& QueryRecordHandle → (funIdx i : @& Nat) → Nat + +/-- Stored values of entry `ptr` in the `memory[size]` map — the deref + of an Aiur `&[T; size]` pointer (empty when unbound). E.g. an + `Addr = &[U8; 32]` argument derefs to its 32 blake3 bytes via + `memKey 32 ptr`. -/ +@[extern "rs_aiur_qr_mem_key"] +opaque memKey : @& QueryRecordHandle → (size ptr : @& Nat) → Array G + +end QueryRecordHandle + /-- Result of an execution FFI call, built directly by Rust (`LeanAiurExecuteResult` in `crates/ffi/src/lean.rs`). `ioData`/`ioMap` -are the flattened `IOBuffer`; see `IOBuffer.ofArrays`. -/ +are the flattened `IOBuffer`; see `IOBuffer.ofArrays`. `record` owns the +execution's `QueryRecord` — drop the `ExecuteResult` (or project the +other fields out) before the next heavy execution to release its RAM. -/ structure ExecuteResult where output : Array G ioData : Array (G × Array G) ioMap : Array ((G × Array G) × IOKeyInfo) queryCounts : Array QueryCount + record : QueryRecordHandle -- =========================================================================== -- EnvHandle: Rust-owned `ixon::Env` exposed to Lean as an opaque handle. @@ -122,6 +169,7 @@ private opaque execute' : @& Bytecode.Toplevel → @& Bytecode.FunIdx → @& Array G → (ioData : @& Array (G × Array G)) → (ioMap : @& Array ((G × Array G) × IOKeyInfo)) → + (profile : Bool) → Except String ExecuteResult /-- Executes the bytecode function `funIdx` with the given `args` and `ioBuffer`, @@ -132,14 +180,24 @@ callers can recover instead of crashing. -/ def execute (toplevel : @& Bytecode.Toplevel) (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) : Except String (Array G × IOBuffer × Array QueryCount) := - (execute' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray).map + (execute' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray false).map fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts) +/-- `execute` variant returning the full `ExecuteResult`, including the + `QueryRecordHandle` for post-run query inspection. `profile` enables + per-entry virtual-span recording (`QueryRecordHandle.fnVspan`). -/ +def executeFull (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) + (profile : Bool := false) : + Except String ExecuteResult := + execute' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray profile + @[extern "rs_aiur_toplevel_execute_ixvm"] private opaque executeIxVM' : @& Bytecode.Toplevel → @& Bytecode.FunIdx → @& Array G → (ioData : @& Array (G × Array G)) → (ioMap : @& Array ((G × Array G) × IOKeyInfo)) → + (profile : Bool) → Except String ExecuteResult /-- IxVM-native execution: same shape as `execute`, but routes the @@ -153,9 +211,19 @@ private opaque executeIxVM' : @& Bytecode.Toplevel → def executeIxVM (toplevel : @& Bytecode.Toplevel) (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) : Except String (Array G × IOBuffer × Array QueryCount) := - (executeIxVM' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray).map + (executeIxVM' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray false).map fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts) +/-- `executeIxVM` variant returning the full `ExecuteResult`, including + the `QueryRecordHandle` for post-run query inspection. `profile` + enables per-entry virtual-span recording + (`QueryRecordHandle.fnVspan`). -/ +def executeIxVMFull (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) + (profile : Bool := false) : + Except String ExecuteResult := + executeIxVM' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray profile + /-- MultiStark-native execution of `verify_multi_stark_proof`: the IO advice buffer (channel 0 = proof, 1 = vk, 2 = claims, key `[0]` each) is built natively in Rust from the raw byte blobs — no @@ -181,7 +249,8 @@ opaque executeMultiStark (toplevel : @& Bytecode.Toplevel) @[extern "rs_aiur_toplevel_check_addr_with_env"] private opaque checkAddrWithEnv' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → + (useBytecode profile : Bool) → Except String ExecuteResult /-- Per-claim check against a Rust-owned `EnvHandle`. `useBytecode` @@ -193,7 +262,7 @@ def checkAddrWithEnv (toplevel : @& Bytecode.Toplevel) (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (addrBytes : ByteArray) (useBytecode : Bool := false) : Except String (Array G × IOBuffer × Array QueryCount) := - (checkAddrWithEnv' toplevel funIdx envHandle addrBytes useBytecode).map + (checkAddrWithEnv' toplevel funIdx envHandle addrBytes useBytecode false).map fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts) @[extern "rs_aiur_toplevel_check_addrs_with_env"] @@ -216,9 +285,21 @@ def checkAddrsWithEnv (toplevel : @& Bytecode.Toplevel) : Except String (Array (String × String)) := checkAddrsWithEnv' toplevel funIdx envHandle addrsBlob useBytecode jobs +/-- `checkAddrWithEnv` variant returning the full `ExecuteResult`, + including the `QueryRecordHandle` for post-run query inspection. + `profile` enables per-entry virtual-span recording + (`QueryRecordHandle.fnVspan`). -/ +def checkAddrWithEnvFull (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) + (addrBytes : ByteArray) (useBytecode : Bool := false) + (profile : Bool := false) + : Except String ExecuteResult := + checkAddrWithEnv' toplevel funIdx envHandle addrBytes useBytecode profile + @[extern "rs_aiur_toplevel_shard_check_with_env"] private opaque shardCheckWithEnv' : @& Bytecode.Toplevel → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → + (useBytecode profile : Bool) → Except String ExecuteResult /-- Per-shard check with the witness shape (wrapper-augmented byte @@ -228,9 +309,20 @@ def shardCheckWithEnv (toplevel : @& Bytecode.Toplevel) (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (ownedBlob : ByteArray) (useBytecode : Bool := false) : Except String (Array G × IOBuffer × Array QueryCount) := - (shardCheckWithEnv' toplevel funIdx envHandle ownedBlob useBytecode).map + (shardCheckWithEnv' toplevel funIdx envHandle ownedBlob useBytecode false).map fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts) +/-- `shardCheckWithEnv` variant returning the full `ExecuteResult`, + including the `QueryRecordHandle` for post-run query inspection. + `profile` enables per-entry virtual-span recording + (`QueryRecordHandle.fnVspan`). -/ +def shardCheckWithEnvFull (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) + (ownedBlob : ByteArray) (useBytecode : Bool := false) + (profile : Bool := false) + : Except String ExecuteResult := + shardCheckWithEnv' toplevel funIdx envHandle ownedBlob useBytecode profile + end Bytecode.Toplevel end Aiur diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean index 3bf36a95a..5c60b659a 100644 --- a/Ix/Aiur/Stages/Codegen.lean +++ b/Ix/Aiur/Stages/Codegen.lean @@ -384,24 +384,34 @@ private def emitCall (out : Nat) (callee : FunIdx) (args : Array ValIdx) -- always skipped; when opUn = false both expressions collapse to -- just `unconstrained`. let cuExpr : String := if opUn then "true" else "unconstrained" - let bumpCond : String := if opUn then "false" else "!unconstrained" + -- On a constrained hit, `replay_at` bumps the multiplicity and returns + -- the entry's virtual-gas replay cost (its recorded standalone span + -- when profiling, else the map weight) to add to `record.virt`. let bumpStmt : String := if opUn then "" - else s!" if {bumpCond} \{ *result.multiplicity += G::ONE; }" + else + s!" if !unconstrained \{ let __r = record.function_queries[{callee}].replay_at(__i); record.virt += __r; }" -- Skip `try_into().unwrap()` on the cache hit: we statically know -- the cached output has exactly `OUT_{callee}` elements (only we -- ever insert into this slot via the matching aiur_fn_{callee} -- `Ctrl::Return`). An unchecked array copy is sound. let retExpr : String := - s!" let __ret: [G; OUT_{callee}] = unsafe \{ *(result.output.as_ptr() as *const [G; OUT_{callee}]) }; __ret" + s!" let __ret: [G; OUT_{callee}] = unsafe \{ *(record.function_queries[{callee}].output_at(__i).as_ptr() as *const [G; OUT_{callee}]) }; __ret" + -- A zero-multiplicity entry was computed only as an unconstrained + -- hint; a constrained caller replays the body (constrained: `__cu` is + -- false on that path) so promotion recurses through the whole + -- dependency tree. Mirrors execute.rs Op::Call. + let hitGuard : String := + if opUn then "true" + else + s!"__cu || record.function_queries[{callee}].mult_at(__i) != G::ZERO" let blockExpr : String := s!"\{ let __args: [G; IN_{callee}] = {argsStr};" ++ s!" let __cu = {cuExpr};" ++ - s!" if let Some(result) = record.function_queries[{callee}].get_mut(&__args[..]) \{" ++ - s!" if !__cu && *result.multiplicity == G::ZERO \{" ++ - s!" aiur_fn_{callee}(__args, record, io_buffer, false)?" ++ - s!" } else \{" ++ bumpStmt ++ retExpr ++ " }" ++ - s!" } else \{ aiur_fn_{callee}(__args, record, io_buffer, __cu)? } }" + s!" let __hit = record.function_queries[{callee}].get_index_of(&__args[..]);" ++ + s!" match __hit \{ Some(__i) if {hitGuard} => \{" ++ + bumpStmt ++ retExpr ++ " }," ++ + s!" _ => aiur_fn_{callee}(__args, record, io_buffer, __cu)? } }" let mut stmts : Array RustStmt := #[ .letStmt false "__r_arr" (some s!"[G; OUT_{callee}]") (.lit blockExpr) ] @@ -417,12 +427,13 @@ private def emitStore (out : Nat) (values : Array ValIdx) : Array RustStmt := let blockExpr : String := s!"\{ let __values: [G; {size}] = {valsStr};" ++ s!" let __mq = record.memory_queries.get_mut(&{size}).ok_or(ExecError::InvalidMemorySize({size}))?;" ++ - s!" if let Some(result) = __mq.get_mut(&__values[..]) \{" ++ - s!" if !unconstrained \{ *result.multiplicity += G::ONE; }" ++ - s!" result.output[0]" ++ + s!" if let Some(__i) = __mq.get_index_of(&__values[..]) \{" ++ + s!" if !unconstrained \{ let __r = __mq.replay_at(__i); record.virt += __r; }" ++ + s!" __mq.output_at(__i)[0]" ++ s!" } else \{" ++ s!" let __ptr = G::from_usize(__mq.len());" ++ - s!" __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }" + s!" __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained));" ++ + s!" if !unconstrained \{ record.virt += __mq.weight(); } __ptr } }" #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] /-- `Op::Load`: mirror execute.rs lines 328-345. Look up by pointer @@ -432,8 +443,9 @@ private def emitLoad (out : Nat) (size : Nat) (ptr : ValIdx) : Array RustStmt := s!"\{ let __mq = record.memory_queries.get_mut(&{size}).ok_or(ExecError::InvalidMemorySize({size}))?;" ++ s!" let __ptr_u64 = __v_{ptr}.as_canonical_u64();" ++ s!" let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?;" ++ - s!" let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer \{ ptr: __ptr_u64, size: {size} })?;" ++ - s!" if !unconstrained \{ *__mult += G::ONE; }" ++ + s!" if __ptr_usize >= __mq.len() \{ return Err(ExecError::UnboundPointer \{ ptr: __ptr_u64, size: {size} }); }" ++ + s!" if !unconstrained \{ let __r = __mq.replay_at(__ptr_usize); record.virt += __r; }" ++ + s!" let (__args, _) = __mq.get_index(__ptr_usize).expect(\"bounds checked above\");" ++ s!" let __arr: [G; {size}] = __args[..{size}].try_into().unwrap(); __arr }" let mut stmts : Array RustStmt := #[ .letStmt false "__loaded" (some s!"[G; {size}]") (.lit blockExpr) @@ -817,13 +829,12 @@ partial def emitCtrl (funIdx : FunIdx) (mcLabel? : Option String) let outArr : RustStmt := .letStmt false "__ret" (some s!"[G; OUT_{funIdx}]") (.arrayLit (outs.map valVar)) + -- `finish` inserts / promotes the row, and (when profiling) + -- records the frame's virtual span measured against the `__vsnap` + -- taken at fn entry. Own-row touch priced before the span is read. let insertCall : RustStmt := .exprStmt (.lit <| - s!"if let Some(result) = record.function_queries[{funIdx}].get_mut(&inp[..]) \{" ++ - " debug_assert_eq!(result.output, &__ret[..]);" ++ - " if !unconstrained { *result.multiplicity += G::ONE; }" ++ - " } else {" ++ - s!" record.function_queries[{funIdx}].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));" ++ - " }") + s!"if !unconstrained \{ record.virt += record.function_queries[{funIdx}].weight(); }" ++ + s!" record.function_queries[{funIdx}].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap)") -- Wrap in Ok(...) since fn now returns Result<[G; OUT_N], ExecError>. return #[outArr, insertCall, .returnStmt (.call (.var "Ok") #[.var "__ret"])] @@ -938,6 +949,9 @@ def emitFunction (funIdx : FunIdx) (f : Function) : Array RustItem := Id.run do s!" unconstrained: bool,\n" ++ s!") -> Result<[G; OUT_{funIdx}], ExecError> {lbrace}\n" ++ s!" stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {lbrace}\n" ++ + -- Virtual-gas snapshot at frame entry; `Ctrl::Return` records the + -- frame's span (`record.virt - __vsnap`) on the registered query. + s!" let __vsnap = record.virt;\n" ++ bodyText ++ s!" {rbrace})\n" ++ s!"{rbrace}\n\n" diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index c9a3caba1..e67a97a5e 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -110,6 +110,38 @@ def emitStats (compiled : Aiur.CompiledToplevel) try Aiur.printStats stats finally let _ ← IO.setStdout old +/-- Append per-constant virtual-gas costs from an execution's + `QueryRecordHandle` to `out`: one ` [name]` + line per constrained `check_const` query. The address is recovered by + dereferencing the `Addr` argument — the LAST input slot, since `ci` + is passed flattened by value — through `memory[32]`; `vspan` is the + constant's standalone check cost (memo hits replay the callee's + recorded span, so the numbers are order-independent shard weights). + Requires the execution to have run with `profile := true`, else + every span reads 0. -/ +def dumpProfile (compiled : Aiur.CompiledToplevel) + (record : Aiur.QueryRecordHandle) (out : String) + (nameOf : Address → Option Ix.Name) : IO Unit := do + let some idx := compiled.getFuncIdx `check_const + | IO.eprintln "--profile: no `check_const` in compiled toplevel" + let addrPos := compiled.bytecode.functions[idx]!.layout.inputSize - 1 + let mut block := "" + for i in [0 : record.fnLen idx] do + let mult := record.fnMult idx i + if mult != 0 then + let key := record.fnKey idx i + if let some addrG := key[addrPos]? then + let limbs := record.memKey 32 addrG.val.toNat + let addr : Address := ⟨.mk <| limbs.map fun g => g.val.toUInt8⟩ + let name := (nameOf addr).map (s!" {·}") |>.getD "" + block := block ++ s!"{addr} {record.fnVspan idx i} {mult}{name}\n" + -- One buffered write per execution: concurrent shard tasks (whole + -- partition mode) append to the same file, and a single O_APPEND + -- write keeps each shard's block from interleaving mid-line. + let h ← IO.FS.Handle.mk out .append + h.putStr block + h.flush + /-- What a single `runOne` invocation is targeting. * `addr`: full-closure `Claim.check addr none` — dispatch via @@ -197,7 +229,9 @@ def runBatchCheck (ixePath : String) (names : List String) (jobs : Nat) The `envHandle?` is `none` only for `.leanW` targets (`--interp` fallback); the addr/shard arms require it. -/ def runCompiled (compiled : Aiur.CompiledToplevel) (printStats : Bool) - (statsOut : Option String) (useBytecode : Bool) + (statsOut : Option String) + (profile? : Option (String × (Address → Option Ix.Name))) + (useBytecode : Bool) (envHandle? : Option Aiur.EnvHandle) (target : Target) (label : String) : IO UInt32 := do IO.println s!"Typechecking {label}" @@ -207,25 +241,28 @@ def runCompiled (compiled : Aiur.CompiledToplevel) (printStats : Bool) let mut blob := ByteArray.empty for x in owned do blob := blob ++ x.hash pure blob + let profile := profile?.isSome let res := match target, envHandle? with | .addr a, some envHandle => - compiled.bytecode.checkAddrWithEnv funIdx envHandle a.hash useBytecode + compiled.bytecode.checkAddrWithEnvFull funIdx envHandle a.hash useBytecode profile | .shard owned, some envHandle => - compiled.bytecode.shardCheckWithEnv funIdx envHandle (buildBlob owned) useBytecode + compiled.bytecode.shardCheckWithEnvFull funIdx envHandle (buildBlob owned) useBytecode profile | .leanW witness, _ => if useBytecode then - compiled.bytecode.execute funIdx witness.input witness.inputIOBuffer + compiled.bytecode.executeFull funIdx witness.input witness.inputIOBuffer profile else - compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer + compiled.bytecode.executeIxVMFull funIdx witness.input witness.inputIOBuffer profile | _, none => .error "internal: addr/shard target with no envHandle" match res with | .error e => IO.eprintln s!"{label}: IxVM-native Aiur execution error: {e}" return 1 - | .ok (_output, _ioBuffer, queryCounts) => - if printStats then emitStats compiled queryCounts statsOut + | .ok r => + if printStats then emitStats compiled r.queryCounts statsOut + if let some (out, nameOf) := profile? then + dumpProfile compiled r.record out nameOf pure 0 /-- Run a single witness through the Aiur interpreter (richer errors). -/ @@ -516,8 +553,8 @@ def runShardOwned (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) the pre-built envHandle so all shards in an all-shards run share one env parse. -/ def runShardOwnedNative (envHandle : Aiur.EnvHandle) (compiled : Aiur.CompiledToplevel) - (printStats : Bool) (statsOut : Option String) (useBytecode : Bool) - (shapes : Array Aiur.CircuitShape) + (printStats : Bool) (statsOut : Option String) (profileOut : Option String) + (useBytecode : Bool) (shapes : Array Aiur.CircuitShape) (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) : IO UInt32 := do let owned := ownedConstsForBlocks ixonEnv blocks IO.println s!"[shard] shard {shardK}: {blocks.size} owned blocks → \ @@ -529,19 +566,21 @@ def runShardOwnedNative (envHandle : Aiur.EnvHandle) (compiled : Aiur.CompiledTo let mut blob := ByteArray.empty for a in owned do blob := blob ++ a.hash - match compiled.bytecode.shardCheckWithEnv funIdx envHandle blob useBytecode with + match compiled.bytecode.shardCheckWithEnvFull funIdx envHandle blob useBytecode profileOut.isSome with | .error e => IO.eprintln s!"{label}: IxVM-native shard check error: {e}" return 1 - | .ok (_output, _ioBuffer, queryCounts) => + | .ok r => -- Prover RAM projection from this shard's executed heights: the -- input to split/merge decisions against a prover budget. - let stats := Aiur.computeStats compiled queryCounts shapes + let stats := Aiur.computeStats compiled r.queryCounts shapes let bytes := stats.projectedProverBytes let gib := Float.ofNat bytes / 1073741824.0 IO.println s!"[shard {shardK}] projected prover RAM: \ {gib} GiB (padded committed traces × blowup)" - if printStats then emitStats compiled queryCounts statsOut + if printStats then emitStats compiled r.queryCounts statsOut + if let some out := profileOut then + dumpProfile compiled r.record out (ixonEnv.addrToName.get? ·) pure 0 /-- Manifest-driven check/prove of one shard `shardK` of the partition. -/ @@ -557,7 +596,8 @@ def runShardCheckManifest (manifestPath ixePath : String) (shardK : Nat) once for this one call. -/ def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) (compiled : Aiur.CompiledToplevel) (printStats : Bool) - (statsOut : Option String) (useBytecode : Bool) : IO UInt32 := do + (statsOut : Option String) (profileOut : Option String) + (useBytecode : Bool) : IO UInt32 := do match (← loadEnvAndShards manifestPath ixePath) with | .error e => IO.eprintln e; return 1 | .ok (ixonEnv, shards) => match shards[shardK]? with @@ -568,7 +608,8 @@ def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) | .ok h => pure h let shapes := Aiur.circuitShapes compiled.bytecode Aiur.defaultCommitmentParameters Aiur.defaultFriParameters - runShardOwnedNative envHandle compiled printStats statsOut useBytecode shapes ixonEnv blocks shardK + runShardOwnedNative envHandle compiled printStats statsOut profileOut + useBytecode shapes ixonEnv blocks shardK /-- Coverage check over already-loaded env + shards: every constant's check-schedule block is owned by **exactly one** shard. That is the whole @@ -711,6 +752,42 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) -- exit (the row is already written), same contract as `check-rs`. return if json?.isSome then Ix.Benchmark.Results.exitRejected else 1 +/-- Per-shard IxVM-native check over EVERY shard, one Lean task per + shard. Slower than `runShardBatchNative` (chunk barriers idle + workers on each wave's slowest shard), but it keeps each shard's + `QueryRecord` Lean-side, which is what `--profile` needs: the + batch FFI returns only a per-shard verdict and prover peak, not + the records the virtual-gas dump reads. Builds the `EnvHandle` + ONCE and shares it across every shard's FFI call (no per-shard + re-mmap). Coverage-gates the manifest before running any shard — + exit 0 has to mean "every env const was checked by some shard", + same soundness contract as `runShardCheckAll`. -/ +def runShardManifestAllNative (manifestPath ixePath : String) (jobs? : Option Nat) + (compiled : Aiur.CompiledToplevel) (printStats : Bool) + (statsOut : Option String) (profileOut : Option String) + (useBytecode : Bool) : IO UInt32 := do + match (← loadEnvAndShards manifestPath ixePath) with + | .error e => IO.eprintln e; return 1 + | .ok (ixonEnv, shards) => + if !(← shardsCover ixonEnv shards) then return 1 + let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 + | .ok h => pure h + let shapes := Aiur.circuitShapes compiled.bytecode + Aiur.defaultCommitmentParameters Aiur.defaultFriParameters + let maxJobs := max 1 (jobs?.getD shards.size) + let mut rc : UInt32 := 0 + for chunk in (shards.mapIdx (fun k b => (b, k))).toList.toChunks maxJobs do + let tasks ← chunk.mapM fun (blocks, k) => + IO.asTask (prio := .dedicated) + (runShardOwnedNative envHandle compiled printStats statsOut profileOut + useBytecode shapes ixonEnv blocks k) + for t in tasks do + match t.get with + | .ok r => if r != 0 then rc := 1 + | .error e => IO.eprintln s!"shard check task failed: {e}"; rc := 1 + pure rc + /-- Run the shard operation over EVERY shard — the whole-partition behavior of `--ixes` with no `--shard` (used by `prove`). Loads the env once. Returns 1 if any shard fails, else 0. -/ @@ -768,6 +845,10 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do let names := (p.variableArgsAs! String).toList let ixesPath := (p.flag? "ixes").map (·.as! String) let shardK := (p.flag? "shard").map (·.as! Nat) + let profileOut := (p.flag? "profile").map (·.as! String) + if profileOut.isSome && interpSource then + IO.eprintln "error: --profile is not available with --interp source" + return 1 -- a single targeted constant, a `--claim`, or a single shard each print -- per-circuit stats; whole-env / whole-partition iteration suppresses them. let printStats := names.length == 1 || claimHex.isSome || (ixesPath.isSome && shardK.isSome) @@ -800,9 +881,14 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c + -- Per-name / per-claim targets carry no addr→name index here (the + -- ixon env loads later, inside `forEachClaim`), so `--profile` + -- lines dump address-only on this path; the shard-native paths + -- below join names via `ixonEnv.addrToName`. + let profile? := profileOut.map ((·, fun _ => none)) let go (_ : Ix.Claim) (envHandle? : Option Aiur.EnvHandle) (target : Target) (label : String) : IO UInt32 := - runCompiled compiled printStats statsOut useBytecode envHandle? target label + runCompiled compiled printStats statsOut profile? useBytecode envHandle? target label pure go match ixePath, ixesPath, shardK with | some ixe, some manifest, some k => @@ -813,7 +899,7 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c - return (← runShardCheckManifestNative manifest ixe k compiled printStats statsOut useBytecode) + return (← runShardCheckManifestNative manifest ixe k compiled printStats statsOut profileOut useBytecode) | some ixe, some manifest, none => if interpSource then return (← runShardCheckAll manifest ixe ((p.flag? "jobs").map (·.as! Nat)) @@ -822,6 +908,13 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c + -- `--profile` needs each shard's `QueryRecord`, which the rayon + -- batch does not hand back; that run takes the per-shard Lean + -- task path instead. + if profileOut.isSome then + return (← runShardManifestAllNative manifest ixe + ((p.flag? "jobs").map (·.as! Nat)) compiled printStats statsOut + profileOut useBytecode) let json? := (p.flag? "json").map fun f => (f.as! String, ((p.flag? "json-name").map (·.as! String)).getD "env") return (← runShardBatchNative manifest ixe @@ -855,6 +948,7 @@ def checkCmd : Cli.Cmd := `[Cli| "ixe" : String; "Path to a serialized `.ixe` env. When set, the binary reads the env from disk instead of using the compiled-in Lean env." "claim" : String; "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, runs the `verify_claim` entrypoint once over the claim's witness against the `--ixe` env (single execution, skips per-const iteration)." "stats-out" : String; "Redirect the per-circuit statistics dump to this file (only used when exactly one constant is targeted)." + "profile" : String; "Append per-constant virtual-gas costs to this file: one ` [name]` line per `check_const` query, read from the execution's QueryRecordHandle (names joined on the shard paths, where the env's addr→name index is loaded). The vspan is the constant's standalone check cost — memo hits replay the callee's recorded span — so the numbers are order-independent shard weights. Not available with `--interp source`." "ixes" : String; "Path to a `.ixes` shard manifest (with --ixe). With --shard K: check the constants owned by shard K (ingress their closure, skip the frontier). Without --shard: check every shard of the partition concurrently, after a coverage check." "shard" : Nat; "0-based shard index K (with --ixe + --ixes): check the constants owned by shard K of the manifest's partition." "jobs" : Nat; "Parallelism. With --ixes (no --shard): max shards checked concurrently (default: all at once). With --ixe alone and N ≠ 1: check the targeted constants on N Rust threads (0 = all cores), each claim over its own private record — peak RAM is bounded by N in-flight claim closures." diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index 3037a1d52..73729b3fa 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -33,23 +33,49 @@ pub struct QueryRecord { pub memory_queries: FxIndexMap, pub bytes1_queries: Bytes1Queries, pub bytes2_queries: Bytes2Queries, + /// Virtual-gas meter: sum of circuit-width-priced constrained query + /// touches, with memo hits replaying the callee's recorded span — the + /// cost of the execution as if nothing were memoized. Never read + /// directly; frame deltas of it become the per-entry spans that + /// `QueryMap::finish` records (surfaced via `QueryRecordHandle`). + pub virt: u64, } impl QueryRecord { - pub fn new(toplevel: &Toplevel) -> Self { + /// `profile` enables per-entry virtual-span recording (readable through + /// the `QueryRecordHandle` FFI accessors); plumbed from the execution + /// entrypoint. + pub fn new(toplevel: &Toplevel, profile: bool) -> Self { + // Weight = committed main-trace width, the per-touch price of a row. + // Unconstrained functions have no circuit, so their rows are free. let function_queries = toplevel .functions .iter() - .map(|f| QueryMap::new(f.layout.input_size)) + .map(|f| { + let weight = + if f.constrained { f.layout.width() as u64 } else { 0 }; + QueryMap::new(f.layout.input_size, weight, profile) + }) .collect(); let memory_queries = toplevel .memory_sizes .iter() - .map(|width| (*width, QueryMap::new(*width))) + .map(|width| { + // Memory circuit width: multiplicity, selector, pointer, values. + // Memory maps never record spans (their replay cost is the + // weight itself), so the profile flag is irrelevant here. + (*width, QueryMap::new(*width, (3 + *width) as u64, false)) + }) .collect(); let bytes1_queries = Bytes1Queries::new(); let bytes2_queries = Bytes2Queries::new(); - Self { function_queries, memory_queries, bytes1_queries, bytes2_queries } + Self { + function_queries, + memory_queries, + bytes1_queries, + bytes2_queries, + virt: 0, + } } } @@ -228,16 +254,19 @@ fn dump_query_stats(record: &QueryRecord, tag: &str) { } impl Toplevel { + /// `profile` enables per-entry virtual-span recording on the returned + /// `QueryRecord` (see `QueryMap::finish`). pub fn execute( &self, fun_idx: FunIdx, args: Vec, io_buffer: &mut IOBuffer, + profile: bool, ) -> Result<(QueryRecord, Vec), ExecError> { if !self.functions[fun_idx].entry { return Err(ExecError::NotEntryFunction(fun_idx)); } - let mut record = QueryRecord::new(self); + let mut record = QueryRecord::new(self, profile); let function = &self.functions[fun_idx]; let output = function.execute(fun_idx, args, self, &mut record, io_buffer)?; @@ -258,6 +287,9 @@ struct CallerState { map: Vec, unconstrained: bool, continuation_depth: usize, + /// `record.virt` at callee entry; the callee's `Ctrl::Return` reads it + /// to record the frame's virtual span on the registered entry. + vsnap: u64, } struct ContinuationState<'a> { @@ -328,23 +360,27 @@ impl Function { ExecEntry::Op(Op::Call(callee_idx, args, _, op_unconstrained)) => { let args: Vec = args.iter().map(|i| map[*i]).collect(); let callee_unconstrained = unconstrained || *op_unconstrained; - let cached_output = record.function_queries[*callee_idx] - .get_mut(&args) - .and_then(|result| { - // A zero-multiplicity entry was computed only as an - // unconstrained hint. Promoting just this row would omit all - // of the callee's child lookups and unbalance their channels; - // replay the body constrained so promotion recurses through - // the whole dependency tree. - if !callee_unconstrained && result.multiplicity.is_zero() { - None - } else { - if !callee_unconstrained { - *result.multiplicity += G::ONE; - } - Some(result.output.to_vec()) + let mut cached_output = None; + if let Some(i) = + record.function_queries[*callee_idx].get_index_of(&args) + { + // A zero-multiplicity entry was computed only as an + // unconstrained hint. Promoting just this row would omit all + // of the callee's child lookups and unbalance their channels; + // replay the body constrained so promotion recurses through + // the whole dependency tree. + let mult = record.function_queries[*callee_idx].mult_at(i); + if callee_unconstrained || !mult.is_zero() { + if !callee_unconstrained { + let replay = + record.function_queries[*callee_idx].replay_at(i); + record.virt += replay; } - }); + cached_output = Some( + record.function_queries[*callee_idx].output_at(i).to_vec(), + ); + } + } if let Some(output) = cached_output { map.extend(output); } else { @@ -354,6 +390,7 @@ impl Function { map: saved_map, unconstrained, continuation_depth: continuation_stack.len(), + vsnap: record.virt, }); fun_idx = *callee_idx; unconstrained = callee_unconstrained; @@ -367,11 +404,11 @@ impl Function { .memory_queries .get_mut(&size) .ok_or(ExecError::InvalidMemorySize(size))?; - if let Some(result) = memory_queries.get_mut(&values) { + if let Some(i) = memory_queries.get_index_of(&values) { if !unconstrained { - *result.multiplicity += G::ONE; + record.virt += memory_queries.replay_at(i); } - map.extend_from_slice(result.output); + map.extend_from_slice(memory_queries.output_at(i)); } else { let ptr = G::from_usize(memory_queries.len()); memory_queries.insert( @@ -379,6 +416,9 @@ impl Function { &[ptr], G::from_bool(!unconstrained), ); + if !unconstrained { + record.virt += memory_queries.weight(); + } map.push(ptr); } }, @@ -392,12 +432,15 @@ impl Function { let ptr_usize = usize::try_from(ptr_u64) .ok() .ok_or(ExecError::PointerTooLarge(ptr_u64))?; - let (args, multiplicity) = memory_queries - .get_index_mut(ptr_usize) - .ok_or(ExecError::UnboundPointer { ptr: ptr_u64, size: *size })?; + if ptr_usize >= memory_queries.len() { + return Err(ExecError::UnboundPointer { ptr: ptr_u64, size: *size }); + } if !unconstrained { - *multiplicity += G::ONE; + record.virt += memory_queries.replay_at(ptr_usize); } + let (args, _) = memory_queries + .get_index(ptr_usize) + .expect("bounds checked above"); map.extend_from_slice(args); }, ExecEntry::Op(Op::AssertEq(xs, ys, msg)) => { @@ -709,30 +752,28 @@ impl Function { push_block_exec_entries!(cont.block); }, ExecEntry::Ctrl(Ctrl::Return(_, output)) => { - // Register the query. + // Register the query, pricing the row's own touch and recording + // the frame's virtual span (own touch + child work, memo hits + // replayed) on the entry. let input_size = toplevel.functions[fun_idx].layout.input_size; let output = output.iter().map(|i| map[*i]).collect::>(); - if let Some(result) = - record.function_queries[fun_idx].get_mut(&map[..input_size]) - { - // The only ordinary way to execute an already cached function - // is constrained promotion of an unconstrained hint entry. - debug_assert_eq!(result.output, output); - if !unconstrained { - *result.multiplicity += G::ONE; - } - } else { - record.function_queries[fun_idx].insert( - &map[..input_size], - &output, - G::from_bool(!unconstrained), - ); + if !unconstrained { + record.virt += record.function_queries[fun_idx].weight(); } + let vsnap = + callers_states_stack.last().map_or(0, |cs| cs.vsnap); + record.function_queries[fun_idx].finish( + &map[..input_size], + &output, + !unconstrained, + record.virt - vsnap, + ); if let Some(CallerState { fun_idx: caller_idx, map: caller_map, unconstrained: caller_unconstrained, continuation_depth, + vsnap: _, }) = callers_states_stack.pop() { continuation_stack.truncate(continuation_depth); diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs index 56f97306e..5ba8a0cf0 100644 --- a/crates/aiur/src/querymap.rs +++ b/crates/aiur/src/querymap.rs @@ -1,4 +1,4 @@ -use multi_stark::p3_field::PrimeField64; +use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; use crate::G; @@ -196,16 +196,17 @@ impl SegStore { } } -/// Segmented store of per-entry key hashes. Kept so hash-table growth can -/// re-insert from stored hashes instead of re-hashing every key from the -/// keys arena — table doubling on a multi-GB map used to be a full -/// sequential re-hash pass over the arena, log-many times. -struct SegHashes { +/// Segmented store of per-entry `u64`s. Used for the key hashes — kept so +/// hash-table growth can re-insert from stored hashes instead of +/// re-hashing every key from the keys arena (table doubling on a multi-GB +/// map used to be a full sequential re-hash pass over the arena, log-many +/// times) — and for the profiling virtual spans. +struct SegU64s { segs: Vec>, entries: usize, } -impl SegHashes { +impl SegU64s { fn new() -> Self { Self { segs: Vec::new(), entries: 0 } } @@ -224,6 +225,11 @@ impl SegHashes { self.segs[seg].extend_from_slice(&[h]); self.entries += 1; } + + #[inline] + fn set(&mut self, i: usize, v: u64) { + self.segs[i >> SEG_BITS].slice_mut(i & SEG_MASK, 1)[0] = v; + } } /// Append-only query store with a hash index. @@ -247,25 +253,47 @@ pub struct QueryMap { /// Output width; inferred on first insert (not statically available in /// `FunctionLayout`). out_stride_set: bool, + /// Committed-trace width of this circuit (0 for unconstrained + /// functions): the per-touch price charged to the virtual-gas meter + /// (`QueryRecord::virt`). + weight: u64, + /// Whether `finish` records per-entry virtual spans (`vspans`). + /// Plumbed from the execution entrypoint's `profile` flag; off by + /// default so the extra u64 arena costs nothing on ordinary runs. + profile: bool, keys: SegStore, outs: SegStore, mults: SegStore, - hashes: SegHashes, + hashes: SegU64s, + /// Per-entry virtual-gas span recorded at the entry's (first + /// constrained) computation — the entry's standalone cost, replayed on + /// memo hits so `virt` prices the execution as if nothing were + /// memoized. Populated only by `finish` (function maps) and only when + /// `profile` is set; memory maps leave it empty and replay `weight`. + vspans: SegU64s, table: hashbrown::HashTable, } impl QueryMap { - pub fn new(key_stride: usize) -> Self { + pub fn new(key_stride: usize, weight: u64, profile: bool) -> Self { Self { out_stride_set: false, + weight, + profile, keys: SegStore::new(key_stride), outs: SegStore::new(0), mults: SegStore::new(1), - hashes: SegHashes::new(), + hashes: SegU64s::new(), + vspans: SegU64s::new(), table: hashbrown::HashTable::new(), } } + #[inline] + pub fn weight(&self) -> u64 { + self.weight + } + #[inline] pub fn len(&self) -> usize { self.mults.entries @@ -307,6 +335,61 @@ impl QueryMap { }) } + /// Multiplicity of entry `i`. + #[inline] + pub fn mult_at(&self, i: usize) -> G { + self.mults.at(i)[0] + } + + /// Output slice of entry `i`. + #[inline] + pub fn output_at(&self, i: usize) -> &[G] { + self.outs.at(i) + } + + /// Constrained memo hit on entry `i`: bump the multiplicity and return + /// the replay cost to add to `QueryRecord::virt` — the entry's recorded + /// virtual span when one exists (function maps under `profile`), else + /// the map weight (memory maps, or profiling off). + #[inline] + pub fn replay_at(&mut self, i: usize) -> u64 { + self.mults.at_mut(i)[0] += G::ONE; + if i < self.vspans.entries { self.vspans.at(i) } else { self.weight } + } + + /// Register a function query at `Ctrl::Return`: insert on first + /// registration, bump + re-span on constrained promotion of a cached + /// hint row. `span` is the virtual-gas span measured over the frame + /// (own-row touch included); recorded only when profiling. Function + /// maps must insert exclusively through here so `vspans` stays aligned + /// with the entry arenas. + pub fn finish(&mut self, key: &[G], output: &[G], constrained: bool, span: u64) { + if let Some(i) = self.get_index_of(key) { + // The only ordinary way to execute an already cached function is + // constrained promotion of an unconstrained hint entry. + debug_assert_eq!(self.outs.at(i), output); + if constrained { + self.mults.at_mut(i)[0] += G::ONE; + if self.profile { + // Overwrite the hint-time span (measured unconstrained, ~0) + // with the span of the constrained replay. + self.vspans.set(i, span); + } + } + } else { + self.insert(key, output, G::from_bool(constrained)); + if self.profile { + self.vspans.push(span); + } + } + } + + /// Recorded virtual span of entry `i` (0 when profiling is off). + #[inline] + pub fn vspan_at(&self, i: usize) -> u64 { + if i < self.vspans.entries { self.vspans.at(i) } else { 0 } + } + /// Append a new entry. The key must not already be present: call sites /// only insert on a confirmed miss, and a same-key re-entrant call /// would loop forever before reaching its own insert. diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 552743c28..303dae6d7 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -317,7 +317,7 @@ impl AiurSystem { // execution error here is a programmer bug, so we unwrap. let (query_record, output) = self .toplevel - .execute(fun_idx, input.to_vec(), io_buffer) + .execute(fun_idx, input.to_vec(), io_buffer, false) .expect("Aiur execution failed during prove"); drop(_g); diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index acf20c60e..aa6ad5c3c 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -35,6 +35,14 @@ static AIUR_SYSTEM_CLASS: LazyLock = static IX_ENV_HANDLE_CLASS: LazyLock = LazyLock::new( ExternalClass::register_with_drop::, ); +/// Opaque handle on an execution's `QueryRecord`, returned inside every +/// `ExecuteResult` so Lean can inspect queries (keys, multiplicities, +/// virtual-gas spans, memory derefs) with its higher-level knowledge +/// (fn names, layouts, addr→name maps). The record is the dominant RAM +/// consumer of an execution — Lean callers should consume and drop it +/// before starting the next heavy execution. +static QUERY_RECORD_CLASS: LazyLock = + LazyLock::new(ExternalClass::register_with_drop::); // ============================================================================= // Lean FFI functions @@ -155,6 +163,7 @@ extern "C" fn rs_aiur_toplevel_execute( args: LeanArray>, io_data_arr: LeanArray>, io_map_arr: LeanArray>, + profile: bool, ) -> LeanExcept { let toplevel = decode_toplevel(&toplevel); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); @@ -164,6 +173,7 @@ extern "C" fn rs_aiur_toplevel_execute( fun_idx, args.map(|x| lean_unbox_g(&x)), &mut io_buffer, + profile, ) { Ok(pair) => pair, Err(err) => return LeanExcept::error_string(&err.to_string()), @@ -172,7 +182,7 @@ extern "C" fn rs_aiur_toplevel_execute( LeanExcept::ok(build_execute_result( &output, &io_buffer, - &query_record, + query_record, &toplevel, )) } @@ -190,6 +200,7 @@ extern "C" fn rs_aiur_toplevel_execute_ixvm( args: LeanArray>, io_data_arr: LeanArray>, io_map_arr: LeanArray>, + profile: bool, ) -> LeanExcept { let toplevel = decode_toplevel(&toplevel); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); @@ -203,6 +214,7 @@ extern "C" fn rs_aiur_toplevel_execute_ixvm( fun_idx, args.map(|x| lean_unbox_g(&x)), &mut io_buffer, + profile, ) { Ok(pair) => pair, Err(err) => return LeanExcept::error_string(&err.to_string()), @@ -211,7 +223,7 @@ extern "C" fn rs_aiur_toplevel_execute_ixvm( LeanExcept::ok(build_execute_result( &output, &io_buffer, - &query_record, + query_record, &toplevel, )) } @@ -323,21 +335,115 @@ fn build_query_counts_array( } /// Helper: build a Lean `ExecuteResult` (output, ioData, ioMap, -/// queryCounts) — the return shape shared by every execute/check FFI. +/// queryCounts, record) — the return shape shared by every execute/check +/// FFI. Takes the `QueryRecord` by value: it moves into an opaque +/// `QueryRecordHandle` (slot 4) that Lean can inspect via the +/// `rs_aiur_qr_*` accessors and that frees when Lean drops the result. fn build_execute_result( output: &[G], io_buffer: &IOBuffer, - query_record: &QueryRecord, + query_record: QueryRecord, toplevel: &aiur::bytecode::Toplevel, ) -> LeanAiurExecuteResult { let result = LeanAiurExecuteResult::alloc(0); result.set_obj(0, build_g_array(output)); result.set_obj(1, build_lean_io_data(io_buffer)); result.set_obj(2, build_lean_io_map(io_buffer)); - result.set_obj(3, build_query_counts_array(query_record, toplevel)); + result.set_obj(3, build_query_counts_array(&query_record, toplevel)); + result.set_obj(4, LeanExternal::alloc(&QUERY_RECORD_CLASS, query_record)); result } +// ============================================================================= +// QueryRecordHandle accessors. All borrow the handle; out-of-range +// indices return 0 / an empty array (callers iterate within `fn_len`). +// ============================================================================= + +/// `QueryRecordHandle.fnLen : @& QueryRecordHandle → @& Nat → Nat` — +/// number of query entries registered for function `idx`. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_qr_fn_len( + handle: LeanExternal>, + fun_idx: LeanNat>, +) -> LeanOwned { + let idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let len = handle.get().function_queries.get(idx).map_or(0, |m| m.len()); + LeanOwned::box_usize(len) +} + +/// `QueryRecordHandle.fnKey : … → Array G` — input tuple of entry `i` +/// of function `idx`. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_qr_fn_key( + handle: LeanExternal>, + fun_idx: LeanNat>, + i: LeanNat>, +) -> LeanArray { + let idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let i = lean_unbox_nat_as_usize(i.inner()); + let key = handle + .get() + .function_queries + .get(idx) + .and_then(|m| m.get_index(i).map(|(k, _)| k)); + build_g_array(key.unwrap_or(&[])) +} + +/// `QueryRecordHandle.fnMult : … → Nat` — multiplicity of entry `i`. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_qr_fn_mult( + handle: LeanExternal>, + fun_idx: LeanNat>, + i: LeanNat>, +) -> LeanOwned { + let idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let i = lean_unbox_nat_as_usize(i.inner()); + let mult = handle + .get() + .function_queries + .get(idx) + .filter(|m| i < m.len()) + .map_or(0, |m| m.mult_at(i).as_canonical_u64()); + LeanOwned::box_usize(usize::try_from(mult).expect("multiplicity fits usize")) +} + +/// `QueryRecordHandle.fnVspan : … → Nat` — recorded virtual-gas span of +/// entry `i` (0 unless the execution ran with `profile = true`). +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_qr_fn_vspan( + handle: LeanExternal>, + fun_idx: LeanNat>, + i: LeanNat>, +) -> LeanOwned { + let idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let i = lean_unbox_nat_as_usize(i.inner()); + let span = handle + .get() + .function_queries + .get(idx) + .map_or(0, |m| m.vspan_at(i)); + LeanOwned::box_usize(usize::try_from(span).expect("vspan fits usize")) +} + +/// `QueryRecordHandle.memKey : … → Array G` — stored values of entry +/// `ptr` in the `memory[size]` map: the deref of an Aiur `&[T; size]` +/// pointer. Empty array when the channel or pointer is unbound. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_qr_mem_key( + handle: LeanExternal>, + size: LeanNat>, + ptr: LeanNat>, +) -> LeanArray { + let size = lean_unbox_nat_as_usize(size.inner()); + let ptr = lean_unbox_nat_as_usize(ptr.inner()); + let key = handle + .get() + .memory_queries + .get(&size) + .and_then(|m| m.get_index(ptr).map(|(k, _)| k)); + build_g_array(key.unwrap_or(&[])) +} + /// Helper: build a Lean `ProveResult` (claim, proof, ioData, ioMap). fn build_prove_result( claim: &[G], @@ -419,6 +525,7 @@ fn dispatch_execute( input: Vec, io_buffer: &mut IOBuffer, use_bytecode: bool, + profile: bool, ) -> Result<(QueryRecord, Vec), String> { // Same span name as the prove pipeline's execution phase // (`synthesis.rs`), so a standalone execute renders/records through the @@ -427,11 +534,11 @@ fn dispatch_execute( let _g = tracing::info_span!("aiur/execute_ixvm").entered(); if use_bytecode { toplevel - .execute(fun_idx, input, io_buffer) + .execute(fun_idx, input, io_buffer, profile) .map_err(|e| format!("execute (bytecode): {e}")) } else { ixvm_codegen::aiur_ixvm_runner::execute_ixvm( - toplevel, fun_idx, input, io_buffer, + toplevel, fun_idx, input, io_buffer, profile, ) .map_err(|e| format!("execute_ixvm: {e}")) } @@ -452,6 +559,7 @@ extern "C" fn rs_aiur_toplevel_check_addr_with_env( >, addr_bytes: LeanByteArray>, use_bytecode: bool, + profile: bool, ) -> LeanExcept { let toplevel = decode_toplevel(&toplevel); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); @@ -476,6 +584,7 @@ extern "C" fn rs_aiur_toplevel_check_addr_with_env( input, &mut io_buffer, use_bytecode, + profile, ) { Ok(p) => p, Err(e) => return LeanExcept::error_string(&e), @@ -484,7 +593,7 @@ extern "C" fn rs_aiur_toplevel_check_addr_with_env( LeanExcept::ok(build_execute_result( &output, &io_buffer, - &query_record, + query_record, &toplevel, )) } @@ -547,6 +656,8 @@ extern "C" fn rs_aiur_toplevel_check_addrs_with_env( input, &mut io_buffer, use_bytecode, + // No vspan meter: the batch keeps no records to read it from. + false, ) .err(), }; @@ -749,6 +860,8 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( input, &mut io_buffer, use_bytecode, + // No vspan meter: only the prover peak is read back per shard. + false, ) { Err(e) => (e, 0), Ok((record, _output)) => { @@ -793,6 +906,7 @@ extern "C" fn rs_aiur_toplevel_shard_check_with_env( >, owned_blob: LeanByteArray>, use_bytecode: bool, + profile: bool, ) -> LeanExcept { let toplevel = decode_toplevel(&toplevel); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); @@ -821,6 +935,7 @@ extern "C" fn rs_aiur_toplevel_shard_check_with_env( input, &mut io_buffer, use_bytecode, + profile, ) { Ok(p) => p, Err(e) => return LeanExcept::error_string(&e), @@ -829,7 +944,7 @@ extern "C" fn rs_aiur_toplevel_shard_check_with_env( LeanExcept::ok(build_execute_result( &output, &io_buffer, - &query_record, + query_record, &toplevel, )) } @@ -875,7 +990,7 @@ extern "C" fn rs_aiur_system_prove_addr_with_env( &input, &mut io_buffer, |toplevel, fun_idx, input, io_buffer| { - toplevel.execute(fun_idx, input, io_buffer) + toplevel.execute(fun_idx, input, io_buffer, false) }, ) } else { @@ -883,7 +998,12 @@ extern "C" fn rs_aiur_system_prove_addr_with_env( fun_idx, &input, &mut io_buffer, - ixvm_codegen::aiur_ixvm_runner::execute_ixvm, + |toplevel, fun_idx, input, io_buffer| { + // The prove path never profiles. + ixvm_codegen::aiur_ixvm_runner::execute_ixvm( + toplevel, fun_idx, input, io_buffer, false, + ) + }, ) }; @@ -924,7 +1044,12 @@ extern "C" fn rs_aiur_system_shard_prove_with_env( fun_idx, &input, &mut io_buffer, - ixvm_codegen::aiur_ixvm_runner::execute_ixvm, + // The prove path never profiles. + |toplevel, fun_idx, input, io_buffer| { + ixvm_codegen::aiur_ixvm_runner::execute_ixvm( + toplevel, fun_idx, input, io_buffer, false, + ) + }, ); LeanExcept::ok(build_prove_env_result(&claim, proof, &io_buffer)) @@ -951,7 +1076,12 @@ extern "C" fn rs_aiur_system_prove_ixvm( fun_idx, &args, &mut io_buffer, - ixvm_codegen::aiur_ixvm_runner::execute_ixvm, + // The prove path never profiles. + |toplevel, fun_idx, input, io_buffer| { + ixvm_codegen::aiur_ixvm_runner::execute_ixvm( + toplevel, fun_idx, input, io_buffer, false, + ) + }, ); build_prove_result(&claim, proof, &io_buffer) @@ -988,7 +1118,7 @@ extern "C" fn rs_aiur_multi_stark_execute( // Same execution-phase span as the prove pipeline. let _g = tracing::info_span!("aiur/execute_multi_stark").entered(); let result = if use_bytecode { - toplevel.execute(fun_idx, input, &mut io_buffer) + toplevel.execute(fun_idx, input, &mut io_buffer, false) } else { ixvm_codegen::aiur_multi_stark_runner::execute_multi_stark( &toplevel, diff --git a/crates/ffi/src/lean.rs b/crates/ffi/src/lean.rs index 44c6fd437..793965627 100644 --- a/crates/ffi/src/lean.rs +++ b/crates/ffi/src/lean.rs @@ -288,8 +288,8 @@ lean_ffi::lean_inductive! { // mainWidth, stage2Width, quotientDegree, preprocessedWidth, // preprocessedHeight LeanAiurCircuitShape [ { num_obj: 5 } ]; - // output, ioData, ioMap, queryCounts - LeanAiurExecuteResult [ { num_obj: 4 } ]; + // output, ioData, ioMap, queryCounts, record (QueryRecordHandle) + LeanAiurExecuteResult [ { num_obj: 5 } ]; // claim, proof, ioData, ioMap LeanAiurProveResult [ { num_obj: 4 } ]; // claimBytes, proof, ioData, ioMap diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index e0b23dee8..62b268cde 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -26,9 +26,10 @@ fn aiur_fn_0( unconstrained: bool, ) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -61,7 +62,7 @@ fn aiur_fn_0( let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -267,13 +268,13 @@ fn aiur_fn_0( 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)); }; + if !unconstrained { record.virt += record.function_queries[0].weight(); } record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_227: G = G::from_u64(0); let __ret: [G; OUT_0] = [__v_227]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[0].weight(); } record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -281,7 +282,7 @@ fn aiur_fn_0( _ => { 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)); }; + if !unconstrained { record.virt += record.function_queries[0].weight(); } record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -289,7 +290,7 @@ fn aiur_fn_0( _ => { 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)); }; + if !unconstrained { record.virt += record.function_queries[0].weight(); } record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -297,7 +298,7 @@ fn aiur_fn_0( _ => { 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)); }; + if !unconstrained { record.virt += record.function_queries[0].weight(); } record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -305,7 +306,7 @@ fn aiur_fn_0( _ => { 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)); }; + if !unconstrained { record.virt += record.function_queries[0].weight(); } record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -322,9 +323,10 @@ fn aiur_fn_1( unconstrained: bool, ) -> Result<[G; OUT_1], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -357,7 +359,7 @@ fn aiur_fn_1( let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -393,16 +395,16 @@ fn aiur_fn_1( let __v_66: G = (__v_2 - __v_34); match __v_66.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -419,6 +421,7 @@ fn aiur_fn_2( unconstrained: bool, ) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -426,9 +429,9 @@ fn aiur_fn_2( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[2].weight(); } record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -436,14 +439,14 @@ fn aiur_fn_2( let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 - __v_5); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __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 __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[2].weight(); } record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -460,6 +463,7 @@ fn aiur_fn_3( unconstrained: bool, ) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -484,13 +488,13 @@ fn aiur_fn_3( 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)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -500,13 +504,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -520,13 +524,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -536,13 +540,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -560,13 +564,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -576,13 +580,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -596,13 +600,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -612,13 +616,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -640,13 +644,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(4); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -656,13 +660,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -676,13 +680,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -692,13 +696,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -716,13 +720,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -732,13 +736,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -752,13 +756,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -768,13 +772,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -800,13 +804,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(3); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -816,13 +820,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -836,13 +840,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -852,13 +856,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -876,13 +880,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -892,13 +896,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -912,13 +916,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -928,13 +932,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -956,13 +960,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(4); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -972,13 +976,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -992,13 +996,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1008,13 +1012,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1032,13 +1036,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1048,13 +1052,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1068,13 +1072,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1084,13 +1088,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1120,13 +1124,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1136,13 +1140,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1156,13 +1160,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1172,13 +1176,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1196,13 +1200,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1212,13 +1216,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1232,13 +1236,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1248,13 +1252,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1276,13 +1280,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(4); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1292,13 +1296,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1312,13 +1316,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1328,13 +1332,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1352,13 +1356,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1368,13 +1372,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1388,13 +1392,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1404,13 +1408,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1436,13 +1440,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(3); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1452,13 +1456,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1472,13 +1476,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1488,13 +1492,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1512,13 +1516,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1528,13 +1532,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1548,13 +1552,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1564,13 +1568,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1592,13 +1596,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(4); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1608,13 +1612,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1628,13 +1632,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1644,13 +1648,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1668,13 +1672,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1684,13 +1688,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1704,13 +1708,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1720,13 +1724,13 @@ fn aiur_fn_3( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1755,6 +1759,7 @@ fn aiur_fn_4( unconstrained: bool, ) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -1781,13 +1786,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1795,7 +1800,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1803,7 +1808,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1811,7 +1816,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1819,7 +1824,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1827,7 +1832,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1835,7 +1840,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1843,7 +1848,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1860,6 +1865,7 @@ fn aiur_fn_5( unconstrained: bool, ) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -1882,7 +1888,7 @@ fn aiur_fn_5( return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1897,6 +1903,7 @@ fn aiur_fn_6( unconstrained: bool, ) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -1929,7 +1936,7 @@ fn aiur_fn_6( return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __ret: [G; OUT_6] = [__v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[6].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[6].weight(); } record.function_queries[6].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1944,6 +1951,7 @@ fn aiur_fn_7( unconstrained: bool, ) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -1957,7 +1965,7 @@ fn aiur_fn_7( let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) }; let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; let __ret: [G; OUT_7] = [__v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[7].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[7].weight(); } record.function_queries[7].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1972,12 +1980,13 @@ fn aiur_fn_8( unconstrained: bool, ) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_8] = [__v_2, __v_3, __v_0, __v_1]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[8].weight(); } record.function_queries[8].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1992,12 +2001,13 @@ fn aiur_fn_9( unconstrained: bool, ) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __ret: [G; OUT_9] = [__v_1, __v_2, __v_3, __v_0]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2012,6 +2022,7 @@ fn aiur_fn_10( unconstrained: bool, ) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2037,7 +2048,7 @@ fn aiur_fn_10( let __v_18: G = (__v_12 + __v_15); let __v_19: G = (__v_14 + __v_9); let __ret: [G; OUT_10] = [__v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[10].weight(); } record.function_queries[10].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2052,6 +2063,7 @@ fn aiur_fn_11( unconstrained: bool, ) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2077,7 +2089,7 @@ fn aiur_fn_11( let __v_18: G = (__v_14 + __v_9); let __v_19: G = (__v_8 + __v_11); let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[11].weight(); } record.function_queries[11].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2092,6 +2104,7 @@ fn aiur_fn_12( unconstrained: bool, ) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2134,13 +2147,13 @@ fn aiur_fn_12( 0u64 => { let __v_24: G = G::from_u64(1); let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2148,7 +2161,7 @@ fn aiur_fn_12( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2156,7 +2169,7 @@ fn aiur_fn_12( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2164,7 +2177,7 @@ fn aiur_fn_12( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2172,7 +2185,7 @@ fn aiur_fn_12( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2180,7 +2193,7 @@ fn aiur_fn_12( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2188,7 +2201,7 @@ fn aiur_fn_12( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2196,7 +2209,7 @@ fn aiur_fn_12( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2213,6 +2226,7 @@ fn aiur_fn_13( unconstrained: bool, ) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2282,7 +2296,7 @@ fn aiur_fn_13( let __v_51: G = __b2_add.1; let __v_52: G = (__v_49 + __v_51); let __ret: [G; OUT_13] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; - if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2297,6 +2311,7 @@ fn aiur_fn_14( unconstrained: bool, ) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2330,7 +2345,7 @@ fn aiur_fn_14( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -2344,7 +2359,7 @@ fn aiur_fn_14( let __v_15: G = G::from_u64(1); let __v_16: G = (__v_7 + __v_15); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2359,7 +2374,7 @@ fn aiur_fn_14( let __v_14: G = G::from_u64(1); let __v_15: G = (__v_6 + __v_14); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2373,7 +2388,7 @@ fn aiur_fn_14( let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2386,7 +2401,7 @@ fn aiur_fn_14( let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 + __v_12); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2398,7 +2413,7 @@ fn aiur_fn_14( let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 + __v_11); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2409,7 +2424,7 @@ fn aiur_fn_14( let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); let __ret: [G; OUT_14] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2419,7 +2434,7 @@ fn aiur_fn_14( let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 + __v_9); let __ret: [G; OUT_14] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2428,7 +2443,7 @@ fn aiur_fn_14( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 + __v_8); let __ret: [G; OUT_14] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2445,6 +2460,7 @@ fn aiur_fn_15( unconstrained: bool, ) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2478,7 +2494,7 @@ fn aiur_fn_15( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -2492,7 +2508,7 @@ fn aiur_fn_15( let __v_15: G = G::from_u64(1); let __v_16: G = (__v_7 - __v_15); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2507,7 +2523,7 @@ fn aiur_fn_15( let __v_14: G = G::from_u64(1); let __v_15: G = (__v_6 - __v_14); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2521,7 +2537,7 @@ fn aiur_fn_15( let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 - __v_13); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2534,7 +2550,7 @@ fn aiur_fn_15( let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 - __v_12); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2546,7 +2562,7 @@ fn aiur_fn_15( let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 - __v_11); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2557,7 +2573,7 @@ fn aiur_fn_15( let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2567,7 +2583,7 @@ fn aiur_fn_15( let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); let __ret: [G; OUT_15] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2576,7 +2592,7 @@ fn aiur_fn_15( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 - __v_8); let __ret: [G; OUT_15] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2593,6 +2609,7 @@ fn aiur_fn_16( unconstrained: bool, ) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2624,7 +2641,7 @@ fn aiur_fn_16( let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_0 + __v_25); let __ret: [G; OUT_16] = [__v_26]; - if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2639,6 +2656,7 @@ fn aiur_fn_17( unconstrained: bool, ) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2653,7 +2671,7 @@ fn aiur_fn_17( let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_0 + __v_11); let __ret: [G; OUT_17] = [__v_12]; - if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[17].weight(); } record.function_queries[17].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2668,6 +2686,7 @@ fn aiur_fn_18( unconstrained: bool, ) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2773,7 +2792,7 @@ fn aiur_fn_18( let __v_102: G = (__v_96 + __v_101); let __v_103: G = (__v_28 + __v_102); let __ret: [G; OUT_18] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103]; - if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[18].weight(); } record.function_queries[18].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2788,6 +2807,7 @@ fn aiur_fn_19( unconstrained: bool, ) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); @@ -2823,7 +2843,7 @@ fn aiur_fn_19( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); @@ -2834,14 +2854,14 @@ fn aiur_fn_19( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); - let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[23].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[23].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -2875,7 +2895,7 @@ fn aiur_fn_19( let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; let __ret: [G; OUT_19] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; - if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[19].weight(); } record.function_queries[19].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2890,6 +2910,7 @@ fn aiur_fn_20( unconstrained: bool, ) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2957,7 +2978,7 @@ fn aiur_fn_20( let __v_64: G = G::from_u64(91); let __v_65: G = G::from_u64(1); let __v_66: G = G::from_u64(1); - let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_68: G = G::from_u64(0); let __v_69: G = G::from_u64(0); let __v_70: G = G::from_u64(0); @@ -2968,14 +2989,14 @@ fn aiur_fn_20( let __v_75: G = G::from_u64(0); let __v_76: G = G::from_u64(0); let __v_77: G = G::from_u64(0); - let __v_78: G = { let __values: [G; 8] = [__v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_79: G = { let __values: [G; 32] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_78: G = { let __values: [G; 8] = [__v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_79: G = { let __values: [G; 32] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_80: G = G::from_u64(1); let __v_81: G = G::from_u64(1); - let __v_82: G = { let __values: [G; 34] = [__v_80, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_67, __v_68, __v_69, __v_78, __v_79, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __v_82: G = { let __values: [G; 34] = [__v_80, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_67, __v_68, __v_69, __v_78, __v_79, __v_82]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_83]; let __cu = unconstrained; let __hit = record.function_queries[23].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[23].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; @@ -3105,7 +3126,7 @@ fn aiur_fn_20( return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } let __ret: [G; OUT_20] = []; - if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[20].weight(); } record.function_queries[20].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -3120,6 +3141,7 @@ fn aiur_fn_21( unconstrained: bool, ) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); @@ -3155,7 +3177,7 @@ fn aiur_fn_21( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); @@ -3166,14 +3188,14 @@ fn aiur_fn_21( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); - let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[23].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[23].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -3206,9 +3228,9 @@ fn aiur_fn_21( let __v_81: G = __r_arr[29]; let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; - let __v_84: G = { let __values: [G; 32] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_84: G = { let __values: [G; 32] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_21] = [__v_84]; - if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[21].weight(); } record.function_queries[21].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -3223,6 +3245,7 @@ fn aiur_fn_22( unconstrained: bool, ) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -3257,7 +3280,7 @@ fn aiur_fn_22( let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -3296,12 +3319,12 @@ fn aiur_fn_22( 1u64 => { let __v_68: G = G::from_u64(1); let __ret: [G; OUT_22] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[22].weight(); } record.function_queries[22].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; let __v_71: G = __r_arr[2]; @@ -3340,7 +3363,7 @@ fn aiur_fn_22( 0u64 => { let __v_103: G = G::from_u64(1); let __ret: [G; OUT_22] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[22].weight(); } record.function_queries[22].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { @@ -3378,7 +3401,7 @@ fn aiur_fn_22( let __v_134: G = G::from_u64(205); let __v_135: G = G::from_u64(224); let __v_136: G = G::from_u64(91); - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; @@ -3449,7 +3472,7 @@ fn aiur_fn_22( let __v_202: G = G::from_u64(0); let __v_203: G = G::from_u64(0); let __v_204: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[32].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[32].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[32].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_205: G = __r_arr[0]; let __v_206: G = __r_arr[1]; let __v_207: G = __r_arr[2]; @@ -3485,9 +3508,9 @@ fn aiur_fn_22( let __v_237: G = G::from_u64(0); let __v_238: G = G::from_u64(0); let __v_239: G = G::from_u64(0); - let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_22] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[22].weight(); } record.function_queries[22].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -3523,7 +3546,7 @@ fn aiur_fn_22( let __v_200: G = G::from_u64(0); let __v_201: G = G::from_u64(0); let __v_202: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[32].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[32].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[32].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_203: G = __r_arr[0]; let __v_204: G = __r_arr[1]; let __v_205: G = __r_arr[2]; @@ -3559,9 +3582,9 @@ fn aiur_fn_22( let __v_235: G = G::from_u64(0); let __v_236: G = G::from_u64(0); let __v_237: G = G::from_u64(0); - let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_22] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[22].weight(); } record.function_queries[22].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -3588,8 +3611,9 @@ fn aiur_fn_23( unconstrained: bool, ) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -3626,7 +3650,7 @@ fn aiur_fn_23( let __v_34: G = __loaded[33]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; @@ -3664,12 +3688,12 @@ fn aiur_fn_23( match __v_35.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_23] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; - if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[23].weight(); } record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __v_72: G = __r_arr[2]; @@ -3706,7 +3730,7 @@ fn aiur_fn_23( let __v_103: G = __r_arr[33]; match __v_70.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_103]; let __cu = unconstrained; let __hit = record.function_queries[23].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[23].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = __r_arr[2]; @@ -3740,13 +3764,13 @@ fn aiur_fn_23( let __v_134: G = __r_arr[30]; let __v_135: G = __r_arr[31]; let __ret: [G; OUT_23] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; - if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[23].weight(); } record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_104: G = G::from_u64(0); - let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[23].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[23].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __r_arr[2]; @@ -3780,7 +3804,7 @@ fn aiur_fn_23( let __v_136: G = __r_arr[30]; let __v_137: G = __r_arr[31]; let __ret: [G; OUT_23] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; - if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[23].weight(); } record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -3807,6 +3831,7 @@ fn aiur_fn_24( unconstrained: bool, ) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -3814,27 +3839,27 @@ fn aiur_fn_24( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_24] = [__v_10]; - if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[24].weight(); } record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; match __v_2.as_canonical_u64() { 63u64 => { - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[28].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[28].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_24] = [__v_12]; - if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[24].weight(); } record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -3842,10 +3867,10 @@ fn aiur_fn_24( let __v_13: G = (__v_2 + __v_12); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_24] = [__v_16]; - if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[24].weight(); } record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -3867,393 +3892,394 @@ fn aiur_fn_25( unconstrained: bool, ) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_97: G = __loaded[0]; let __v_98: G = __loaded[1]; let __v_99: G = __loaded[2]; match __v_97.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_100: G = __loaded[0]; let __v_101: G = __loaded[1]; let __v_102: G = __loaded[2]; match __v_100.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_127: G = __loaded[0]; let __v_128: G = __loaded[1]; let __v_129: G = __loaded[2]; match __v_127.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_130: G = __loaded[0]; let __v_131: G = __loaded[1]; let __v_132: G = __loaded[2]; match __v_130.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_133: G = __loaded[0]; let __v_134: G = __loaded[1]; let __v_135: G = __loaded[2]; match __v_133.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; match __v_136.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_139: G = __loaded[0]; let __v_140: G = __loaded[1]; let __v_141: G = __loaded[2]; match __v_139.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_142: G = __loaded[0]; let __v_143: G = __loaded[1]; let __v_144: G = __loaded[2]; match __v_142.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_145: G = __loaded[0]; let __v_146: G = __loaded[1]; let __v_147: G = __loaded[2]; match __v_145.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_148: G = __loaded[0]; let __v_149: G = __loaded[1]; let __v_150: G = __loaded[2]; match __v_148.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_151: G = __loaded[0]; let __v_152: G = __loaded[1]; let __v_153: G = __loaded[2]; match __v_151.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_154: G = __loaded[0]; let __v_155: G = __loaded[1]; let __v_156: G = __loaded[2]; match __v_154.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_157: G = __loaded[0]; let __v_158: G = __loaded[1]; let __v_159: G = __loaded[2]; match __v_157.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_160: G = __loaded[0]; let __v_161: G = __loaded[1]; let __v_162: G = __loaded[2]; match __v_160.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_163: G = __loaded[0]; let __v_164: G = __loaded[1]; let __v_165: G = __loaded[2]; match __v_163.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_166: G = __loaded[0]; let __v_167: G = __loaded[1]; let __v_168: G = __loaded[2]; match __v_166.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; match __v_169.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_172: G = __loaded[0]; let __v_173: G = __loaded[1]; let __v_174: G = __loaded[2]; match __v_172.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_175: G = __loaded[0]; let __v_176: G = __loaded[1]; let __v_177: G = __loaded[2]; match __v_175.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; match __v_178.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_181: G = __loaded[0]; let __v_182: G = __loaded[1]; let __v_183: G = __loaded[2]; match __v_181.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_184: G = __loaded[0]; let __v_185: G = __loaded[1]; let __v_186: G = __loaded[2]; match __v_184.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_187: G = __loaded[0]; let __v_188: G = __loaded[1]; let __v_189: G = __loaded[2]; match __v_187.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_190: G = __loaded[0]; let __v_191: G = __loaded[1]; let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_25] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; - if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[25].weight(); } record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -4588,24 +4614,25 @@ fn aiur_fn_26( unconstrained: bool, ) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_26] = [__v_0]; - if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[26].weight(); } record.function_queries[26].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[26].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_26] = [__v_7]; - if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[26].weight(); } record.function_queries[26].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -4622,6 +4649,7 @@ fn aiur_fn_27( unconstrained: bool, ) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -4635,7 +4663,7 @@ fn aiur_fn_27( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -4662,7 +4690,7 @@ fn aiur_fn_27( 0u64 => { let __v_17: G = (__v_6 + __v_7); let __v_18: G = (__v_8 + __v_17); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -4759,7 +4787,7 @@ fn aiur_fn_27( let __v_112: G = G::from_u64(0); let __v_113: G = G::from_u64(0); let __v_114: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; @@ -4793,7 +4821,7 @@ fn aiur_fn_27( let __v_145: G = G::from_u64(0); let __v_146: G = G::from_u64(0); let __v_147: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[32].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[32].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[32].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __v_150: G = __r_arr[2]; @@ -4826,70 +4854,70 @@ fn aiur_fn_27( let __v_177: G = __r_arr[29]; let __v_178: G = __r_arr[30]; let __v_179: G = __r_arr[31]; - let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_27] = [__v_180]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -4922,15 +4950,15 @@ fn aiur_fn_27( let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; - let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_27] = [__v_42]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -4939,7 +4967,7 @@ fn aiur_fn_27( let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 * __v_8); let __v_19: G = (__v_2 - __v_1); @@ -4949,9 +4977,9 @@ fn aiur_fn_27( let __v_23: G = (__v_7 + __v_22); let __v_24: G = G::from_u64(64); let __v_25: G = (__v_24 - __v_1); - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[26].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -5016,7 +5044,7 @@ fn aiur_fn_27( let __v_88: G = __r_arr[61]; let __v_89: G = __r_arr[62]; let __v_90: G = __r_arr[63]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; @@ -5049,7 +5077,7 @@ fn aiur_fn_27( let __v_120: G = __loaded[29]; let __v_121: G = __loaded[30]; let __v_122: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_123: G = __loaded[0]; let __v_124: G = __loaded[1]; let __v_125: G = __loaded[2]; @@ -5082,7 +5110,7 @@ fn aiur_fn_27( let __v_152: G = G::from_u64(0); let __v_153: G = G::from_u64(0); let __v_154: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[32].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[32].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[32].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_155: G = __r_arr[0]; let __v_156: G = __r_arr[1]; let __v_157: G = __r_arr[2]; @@ -5115,9 +5143,9 @@ fn aiur_fn_27( let __v_184: G = __r_arr[29]; let __v_185: G = __r_arr[30]; let __v_186: G = __r_arr[31]; - let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_27] = [__v_187]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -5134,6 +5162,7 @@ fn aiur_fn_28( unconstrained: bool, ) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -5143,7 +5172,7 @@ fn aiur_fn_28( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -5210,9 +5239,9 @@ fn aiur_fn_28( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[768].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[768].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; let __v_75: G = __loaded[1]; let __v_76: G = __loaded[2]; @@ -5221,7 +5250,7 @@ fn aiur_fn_28( let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = (__v_73 * __v_82); let __v_84: G = (__v_8 * __v_83); @@ -5258,7 +5287,7 @@ fn aiur_fn_28( let __v_115: G = G::from_u64(205); let __v_116: G = G::from_u64(224); let __v_117: G = G::from_u64(91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; @@ -5291,7 +5320,7 @@ fn aiur_fn_28( let __v_147: G = __loaded[29]; let __v_148: G = __loaded[30]; let __v_149: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_150: G = __loaded[0]; let __v_151: G = __loaded[1]; let __v_152: G = __loaded[2]; @@ -5325,7 +5354,7 @@ fn aiur_fn_28( let __v_180: G = G::from_u64(0); let __v_181: G = G::from_u64(0); let __v_182: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[32].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[32].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[32].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_183: G = __r_arr[0]; let __v_184: G = __r_arr[1]; let __v_185: G = __r_arr[2]; @@ -5358,13 +5387,13 @@ fn aiur_fn_28( let __v_212: G = __r_arr[29]; let __v_213: G = __r_arr[30]; let __v_214: G = __r_arr[31]; - let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_216: G = G::from_u64(1); let __v_217: G = G::from_u64(1); - let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_219: G = G::from_u64(0); let __v_220: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_221: G = __loaded[0]; let __v_222: G = __loaded[1]; let __v_223: G = __loaded[2]; @@ -5373,7 +5402,7 @@ fn aiur_fn_28( let __v_226: G = __loaded[5]; let __v_227: G = __loaded[6]; let __v_228: G = __loaded[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_229: G = __r_arr[0]; let __v_230: G = __r_arr[1]; let __v_231: G = __r_arr[2]; @@ -5382,21 +5411,21 @@ fn aiur_fn_28( let __v_234: G = __r_arr[5]; let __v_235: G = __r_arr[6]; let __v_236: G = __r_arr[7]; - let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_239: G = __r_arr[0]; let __ret: [G; OUT_28] = [__v_239]; - if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[768].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[768].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[768].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[768].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; @@ -5405,7 +5434,7 @@ fn aiur_fn_28( let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = (__v_84 * __v_8); let __v_86: G = (__v_75 * __v_85); @@ -5415,7 +5444,7 @@ fn aiur_fn_28( let __v_90: G = (__v_89 * __v_6); let __v_91: G = (__v_86 + __v_90); let __v_92: G = (__v_74 + __v_91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; @@ -5448,7 +5477,7 @@ fn aiur_fn_28( let __v_122: G = __loaded[29]; let __v_123: G = __loaded[30]; let __v_124: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_125: G = __loaded[0]; let __v_126: G = __loaded[1]; let __v_127: G = __loaded[2]; @@ -5481,7 +5510,7 @@ fn aiur_fn_28( let __v_154: G = G::from_u64(0); let __v_155: G = G::from_u64(0); let __v_156: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[32].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[32].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[32].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __v_157: G = __r_arr[0]; let __v_158: G = __r_arr[1]; let __v_159: G = __r_arr[2]; @@ -5516,15 +5545,15 @@ fn aiur_fn_28( let __v_188: G = __r_arr[31]; let __v_189: G = G::from_u64(1); let __v_190: G = G::from_u64(1); - let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_192: G = G::from_u64(0); let __v_193: G = G::from_u64(1); let __v_194: G = (__v_2 + __v_193); - let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_196: G = __r_arr[0]; let __ret: [G; OUT_28] = [__v_196]; - if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -5541,6 +5570,7 @@ fn aiur_fn_29( unconstrained: bool, ) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -5670,7 +5700,7 @@ fn aiur_fn_29( let __v_90: G = (__v_84 + __v_87); let __v_91: G = (__v_86 + __v_81); let __ret: [G; OUT_29] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70]; - if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[29].weight(); } record.function_queries[29].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -5685,6 +5715,7 @@ fn aiur_fn_30( unconstrained: bool, ) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -6646,7 +6677,7 @@ fn aiur_fn_30( let __v_670: G = (__v_664 + __v_667); let __v_671: G = (__v_666 + __v_661); let __ret: [G; OUT_30] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; - if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[30].weight(); } record.function_queries[30].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -6661,6 +6692,7 @@ fn aiur_fn_31( unconstrained: bool, ) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -6790,7 +6822,7 @@ fn aiur_fn_31( let __v_126: G = G::from_u64(0); let __v_127: G = G::from_u64(0); let __v_128: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; let __hit = record.function_queries[32].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[32].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[32].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => aiur_fn_32(__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]; @@ -6824,7 +6856,7 @@ fn aiur_fn_31( let __v_159: G = __r_arr[30]; let __v_160: G = __r_arr[31]; let __ret: [G; OUT_31] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; - if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[31].weight(); } record.function_queries[31].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -6839,6 +6871,7 @@ fn aiur_fn_32( unconstrained: bool, ) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -7003,7 +7036,7 @@ fn aiur_fn_32( let __v_159: G = if unconstrained { Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record) }; let __v_160: G = if unconstrained { Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record) }; let __ret: [G; OUT_32] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; - if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[32].weight(); } record.function_queries[32].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -7841,7 +7874,7 @@ fn aiur_fn_32( let __v_672: G = (__v_667 + __v_662); let __v_673: G = G::from_u64(1); let __v_674: G = (__v_0 + __v_673); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[32].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[32].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[32].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => aiur_fn_32(__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]; @@ -7875,7 +7908,7 @@ fn aiur_fn_32( let __v_705: G = __r_arr[30]; let __v_706: G = __r_arr[31]; let __ret: [G; OUT_32] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706]; - if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[32].weight(); } record.function_queries[32].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -7892,6 +7925,7 @@ fn aiur_fn_33( unconstrained: bool, ) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -7914,22 +7948,22 @@ fn aiur_fn_33( match __v_0.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[754].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[754].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[754].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_754] = unsafe { *(record.function_queries[754].output_at(__i).as_ptr() as *const [G; OUT_754]) }; __ret }, _ => aiur_fn_754(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7939,18 +7973,18 @@ fn aiur_fn_33( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_30]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[754].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[754].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[754].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_754] = unsafe { *(record.function_queries[754].output_at(__i).as_ptr() as *const [G; OUT_754]) }; __ret }, _ => aiur_fn_754(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7960,18 +7994,18 @@ fn aiur_fn_33( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(3); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_30]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -7991,34 +8025,34 @@ fn aiur_fn_33( let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __v_37: G = G::from_u64(4); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_40]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __v_19: G = G::from_u64(5); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __v_19: G = G::from_u64(6); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8028,16 +8062,16 @@ fn aiur_fn_33( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(7); - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_29]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[40].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8047,16 +8081,16 @@ fn aiur_fn_33( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(8); - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[43].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[43].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[43].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => aiur_fn_43(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_29]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[41].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[41].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[41].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8066,16 +8100,16 @@ fn aiur_fn_33( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(9); - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[44].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_29]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 10u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -8094,7 +8128,7 @@ fn aiur_fn_33( let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; @@ -8113,7 +8147,7 @@ fn aiur_fn_33( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; @@ -8133,24 +8167,24 @@ fn aiur_fn_33( let __v_71: G = __loaded[16]; let __v_72: G = __loaded[17]; let __v_73: G = G::from_u64(10); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_77]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 11u64 => { let __v_19: G = G::from_u64(11); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -8170,6 +8204,7 @@ fn aiur_fn_34( unconstrained: bool, ) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -8183,7 +8218,7 @@ fn aiur_fn_34( match __v_8.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_34] = [__v_9]; - if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -8191,11 +8226,11 @@ fn aiur_fn_34( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_8 - __v_12); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_34] = [__v_15]; - if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8212,6 +8247,7 @@ fn aiur_fn_35( unconstrained: bool, ) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -8221,7 +8257,7 @@ fn aiur_fn_35( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[3].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[3].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(128); let __v_11: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_10) } else { bytes2_less_than_value(__v_0, __v_10, record) }; @@ -8230,9 +8266,9 @@ fn aiur_fn_35( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_35] = [__v_13]; - if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[35].weight(); } record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -8241,11 +8277,11 @@ fn aiur_fn_35( let __v_14: G = (__v_9 - __v_13); let __v_15: G = (__v_12 + __v_14); let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_35] = [__v_18]; - if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[35].weight(); } record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8256,11 +8292,11 @@ fn aiur_fn_35( let __v_14: G = (__v_9 - __v_13); let __v_15: G = (__v_12 + __v_14); let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_35] = [__v_18]; - if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[35].weight(); } record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8277,6 +8313,7 @@ fn aiur_fn_36( unconstrained: bool, ) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -8287,7 +8324,7 @@ fn aiur_fn_36( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[3].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[3].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(32); let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) }; @@ -8299,9 +8336,9 @@ fn aiur_fn_36( let __v_14: G = (__v_0 * __v_13); let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_36] = [__v_17]; - if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[36].weight(); } record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -8313,11 +8350,11 @@ fn aiur_fn_36( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_36] = [__v_22]; - if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[36].weight(); } record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8331,11 +8368,11 @@ fn aiur_fn_36( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_36] = [__v_22]; - if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[36].weight(); } record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8352,6 +8389,7 @@ fn aiur_fn_37( unconstrained: bool, ) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -8362,7 +8400,7 @@ fn aiur_fn_37( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[3].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[3].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) }; @@ -8374,9 +8412,9 @@ fn aiur_fn_37( let __v_14: G = (__v_0 * __v_13); let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_37] = [__v_17]; - if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[37].weight(); } record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -8388,11 +8426,11 @@ fn aiur_fn_37( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_37] = [__v_22]; - if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[37].weight(); } record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8406,11 +8444,11 @@ fn aiur_fn_37( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_37] = [__v_22]; - if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[37].weight(); } record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8427,9 +8465,10 @@ fn aiur_fn_38( unconstrained: bool, ) -> Result<[G; OUT_38], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -8443,16 +8482,16 @@ fn aiur_fn_38( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_38] = [__v_1]; - if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[38].weight(); } record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_38] = [__v_13]; - if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[38].weight(); } record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -8472,6 +8511,7 @@ fn aiur_fn_39( unconstrained: bool, ) -> Result<[G; OUT_39], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -8492,7 +8532,7 @@ fn aiur_fn_39( let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { 7u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -8511,7 +8551,7 @@ fn aiur_fn_39( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -8520,7 +8560,7 @@ fn aiur_fn_39( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -8530,7 +8570,7 @@ fn aiur_fn_39( let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __ret: [G; OUT_39] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; - if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[39].weight(); } record.function_queries[39].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -8543,7 +8583,7 @@ fn aiur_fn_39( let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); let __ret: [G; OUT_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[39].weight(); } record.function_queries[39].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8560,6 +8600,7 @@ fn aiur_fn_40( unconstrained: bool, ) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -8580,7 +8621,7 @@ fn aiur_fn_40( let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { 8u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -8599,7 +8640,7 @@ fn aiur_fn_40( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[40].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -8608,7 +8649,7 @@ fn aiur_fn_40( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -8618,7 +8659,7 @@ fn aiur_fn_40( let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __ret: [G; OUT_40] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[40].weight(); } record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -8631,7 +8672,7 @@ fn aiur_fn_40( let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); let __ret: [G; OUT_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[40].weight(); } record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8648,6 +8689,7 @@ fn aiur_fn_41( unconstrained: bool, ) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -8668,7 +8710,7 @@ fn aiur_fn_41( let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { 9u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -8687,7 +8729,7 @@ fn aiur_fn_41( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[41].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[41].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[41].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -8696,7 +8738,7 @@ fn aiur_fn_41( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -8706,7 +8748,7 @@ fn aiur_fn_41( let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __ret: [G; OUT_41] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; - if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[41].weight(); } record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -8719,7 +8761,7 @@ fn aiur_fn_41( let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); let __ret: [G; OUT_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[41].weight(); } record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8736,6 +8778,7 @@ fn aiur_fn_42( unconstrained: bool, ) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -8757,7 +8800,7 @@ fn aiur_fn_42( let __v_18: G = inp[18]; match __v_0.as_canonical_u64() { 7u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -8776,7 +8819,7 @@ fn aiur_fn_42( let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; @@ -8795,19 +8838,19 @@ fn aiur_fn_42( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_42] = [__v_56]; - if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[42].weight(); } record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_42] = [__v_19]; - if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[42].weight(); } record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8824,6 +8867,7 @@ fn aiur_fn_43( unconstrained: bool, ) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -8845,7 +8889,7 @@ fn aiur_fn_43( let __v_18: G = inp[18]; match __v_0.as_canonical_u64() { 8u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -8864,7 +8908,7 @@ fn aiur_fn_43( let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; @@ -8883,19 +8927,19 @@ fn aiur_fn_43( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[43].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[43].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[43].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => aiur_fn_43(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_43] = [__v_56]; - if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[43].weight(); } record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_43] = [__v_19]; - if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[43].weight(); } record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8912,6 +8956,7 @@ fn aiur_fn_44( unconstrained: bool, ) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -8933,7 +8978,7 @@ fn aiur_fn_44( let __v_18: G = inp[18]; match __v_0.as_canonical_u64() { 9u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -8952,7 +8997,7 @@ fn aiur_fn_44( let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; @@ -8971,19 +9016,19 @@ fn aiur_fn_44( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[44].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_44] = [__v_56]; - if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[44].weight(); } record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_44] = [__v_19]; - if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[44].weight(); } record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -9000,9 +9045,10 @@ fn aiur_fn_45( unconstrained: bool, ) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -9036,71 +9082,71 @@ fn aiur_fn_45( let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_48: G = G::from_u64(0); - let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_50: G = G::from_u64(0); - let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_54: G = G::from_u64(0); - let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_56: G = G::from_u64(0); - let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_58: G = G::from_u64(0); - let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_60: G = G::from_u64(0); - let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_62: G = G::from_u64(0); - let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_64: G = G::from_u64(0); - let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_68: G = G::from_u64(0); - let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_70: G = G::from_u64(0); - let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_72: G = G::from_u64(0); - let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_74: G = G::from_u64(0); - let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_76: G = G::from_u64(0); - let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_78: G = G::from_u64(0); - let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_80: G = G::from_u64(0); - let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_82: G = G::from_u64(0); - let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_84: G = G::from_u64(0); - let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_86: G = G::from_u64(0); - let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_88: G = G::from_u64(0); - let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_90: G = G::from_u64(0); - let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_92: G = G::from_u64(0); - let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_94: G = G::from_u64(0); - let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_96: G = G::from_u64(0); - let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_45] = [__v_97]; - if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[45].weight(); } record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -9115,6 +9161,7 @@ fn aiur_fn_46( unconstrained: bool, ) -> Result<[G; OUT_46], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { @@ -9123,19 +9170,19 @@ fn aiur_fn_46( 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(2); let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -9148,19 +9195,19 @@ fn aiur_fn_46( 0u64 => { let __v_2: G = G::from_u64(4); let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(5); let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(6); let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -9173,19 +9220,19 @@ fn aiur_fn_46( 0u64 => { let __v_2: G = G::from_u64(8); let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(9); let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(10); let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -9210,6 +9257,7 @@ fn aiur_fn_47( unconstrained: bool, ) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -9221,7 +9269,7 @@ fn aiur_fn_47( let __v_8: G = inp[8]; match __v_0.as_canonical_u64() { 1u64 => { - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -9231,7 +9279,7 @@ fn aiur_fn_47( let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9240,7 +9288,7 @@ fn aiur_fn_47( let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -9250,7 +9298,7 @@ fn aiur_fn_47( let __v_32: G = __r_arr[6]; let __v_33: G = __r_arr[7]; let __ret: [G; OUT_47] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -9263,7 +9311,7 @@ fn aiur_fn_47( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __ret: [G; OUT_47] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -9280,6 +9328,7 @@ fn aiur_fn_48( unconstrained: bool, ) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -9291,7 +9340,7 @@ fn aiur_fn_48( let __v_8: G = inp[8]; match __v_0.as_canonical_u64() { 1u64 => { - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -9301,7 +9350,7 @@ fn aiur_fn_48( let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[48].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9312,12 +9361,12 @@ fn aiur_fn_48( let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; let __ret: [G; OUT_48] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[48].weight(); } record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[48].weight(); } record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -9334,6 +9383,7 @@ fn aiur_fn_49( unconstrained: bool, ) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -9348,13 +9398,13 @@ fn aiur_fn_49( 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_49] = [__v_12]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[49].weight(); } record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -9363,7 +9413,7 @@ fn aiur_fn_49( let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[48].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9374,16 +9424,16 @@ fn aiur_fn_49( let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[49].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[49].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[49].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_49] = [__v_29]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[49].weight(); } record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -9393,7 +9443,7 @@ fn aiur_fn_49( let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -9412,18 +9462,18 @@ fn aiur_fn_49( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[49].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[49].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[49].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[49].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[49].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[49].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_49] = [__v_39]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[49].weight(); } record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -9433,7 +9483,7 @@ fn aiur_fn_49( let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -9452,22 +9502,22 @@ fn aiur_fn_49( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[49].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[49].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[49].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[49].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[49].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[49].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_49] = [__v_39]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[49].weight(); } record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_49] = [__v_11]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[49].weight(); } record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -9487,20 +9537,21 @@ fn aiur_fn_50( unconstrained: bool, ) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_50] = [__v_1]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[50].weight(); } record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -9519,12 +9570,12 @@ fn aiur_fn_50( let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[50].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_50] = [__v_24]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[50].weight(); } record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -9544,20 +9595,21 @@ fn aiur_fn_51( unconstrained: bool, ) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_51] = [__v_1]; - if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[51].weight(); } record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -9567,12 +9619,12 @@ fn aiur_fn_51( let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[49].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[49].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[49].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_51] = [__v_15]; - if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[51].weight(); } record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -9592,25 +9644,26 @@ fn aiur_fn_52( unconstrained: bool, ) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_52] = [__v_1]; - if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[52].weight(); } record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[52].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[45].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_52] = [__v_6]; - if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[52].weight(); } record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -9630,39 +9683,40 @@ fn aiur_fn_53( unconstrained: bool, ) -> Result<[G; OUT_53], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_53] = [__v_4]; - if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[53].weight(); } record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_53] = [__v_4]; - if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[53].weight(); } record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(2); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_53] = [__v_4]; - if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[53].weight(); } record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(3); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_53] = [__v_4]; - if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[53].weight(); } record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -9682,6 +9736,7 @@ fn aiur_fn_54( unconstrained: bool, ) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -9697,7 +9752,7 @@ fn aiur_fn_54( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -9716,7 +9771,7 @@ fn aiur_fn_54( let __v_28: G = __loaded[15]; let __v_29: G = __loaded[16]; let __v_30: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; @@ -9735,18 +9790,18 @@ fn aiur_fn_54( let __v_46: G = __loaded[15]; let __v_47: G = __loaded[16]; let __v_48: G = __loaded[17]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_54] = [__v_54]; - if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[54].weight(); } record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -9763,6 +9818,7 @@ fn aiur_fn_55( unconstrained: bool, ) -> Result<[G; OUT_55], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -9775,7 +9831,7 @@ fn aiur_fn_55( let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -9794,12 +9850,12 @@ fn aiur_fn_55( let __v_25: G = __loaded[15]; let __v_26: G = __loaded[16]; let __v_27: G = __loaded[17]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_55] = [__v_29]; - if let Some(result) = record.function_queries[55].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[55].weight(); } record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -9816,9 +9872,10 @@ fn aiur_fn_56( unconstrained: bool, ) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -9833,16 +9890,16 @@ fn aiur_fn_56( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_56] = [__v_1]; - if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[56].weight(); } record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_12, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[56].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_56] = [__v_14]; - if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[56].weight(); } record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -9862,6 +9919,7 @@ fn aiur_fn_57( unconstrained: bool, ) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -9909,7 +9967,7 @@ fn aiur_fn_57( let __v_44: G = inp[44]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_45: G = __loaded[0]; let __v_46: G = __loaded[1]; let __v_47: G = __loaded[2]; @@ -9931,7 +9989,7 @@ fn aiur_fn_57( let __v_63: G = G::from_u64(2); let __v_64: G = (__v_63 * __v_1); let __v_65: G = (__v_0 + __v_64); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[766].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -9941,25 +9999,25 @@ fn aiur_fn_57( let __v_72: G = __r_arr[6]; let __v_73: G = __r_arr[7]; let __v_74: G = G::from_u64(0); - let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_43, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[56].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; - let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_57] = [__v_83]; - if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[57].weight(); } record.function_queries[57].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -9976,6 +10034,7 @@ fn aiur_fn_58( unconstrained: bool, ) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -9989,7 +10048,7 @@ fn aiur_fn_58( let __v_10: G = inp[10]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -10009,13 +10068,13 @@ fn aiur_fn_58( let __v_27: G = __loaded[16]; let __v_28: G = __loaded[17]; let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_58] = [__v_32]; - if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[58].weight(); } record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -10032,6 +10091,7 @@ fn aiur_fn_59( unconstrained: bool, ) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -10045,7 +10105,7 @@ fn aiur_fn_59( let __v_10: G = inp[10]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -10064,14 +10124,14 @@ fn aiur_fn_59( let __v_26: G = __loaded[15]; let __v_27: G = __loaded[16]; let __v_28: G = __loaded[17]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[53].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[53].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_59] = [__v_31]; - if let Some(result) = record.function_queries[59].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[59].weight(); } record.function_queries[59].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -10088,6 +10148,7 @@ fn aiur_fn_60( unconstrained: bool, ) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -10125,7 +10186,7 @@ fn aiur_fn_60( let __v_34: G = inp[34]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; @@ -10145,19 +10206,19 @@ fn aiur_fn_60( let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_60] = [__v_59]; - if let Some(result) = record.function_queries[60].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[60].weight(); } record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -10174,9 +10235,10 @@ fn aiur_fn_61( unconstrained: bool, ) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -10216,16 +10278,16 @@ fn aiur_fn_61( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_61] = [__v_1]; - if let Some(result) = record.function_queries[61].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[61].weight(); } record.function_queries[61].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_37, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[61].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[61].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[61].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_61] = unsafe { *(record.function_queries[61].output_at(__i).as_ptr() as *const [G; OUT_61]) }; __ret }, _ => aiur_fn_61(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_60(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[60].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[60].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_60] = unsafe { *(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60]) }; __ret }, _ => aiur_fn_60(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_61] = [__v_39]; - if let Some(result) = record.function_queries[61].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[61].weight(); } record.function_queries[61].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -10245,6 +10307,7 @@ fn aiur_fn_62( unconstrained: bool, ) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -10275,7 +10338,7 @@ fn aiur_fn_62( let __v_27: G = inp[27]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; @@ -10294,7 +10357,7 @@ fn aiur_fn_62( let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; - let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[761].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[761].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[761].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_761] = unsafe { *(record.function_queries[761].output_at(__i).as_ptr() as *const [G; OUT_761]) }; __ret }, _ => aiur_fn_761(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -10304,21 +10367,21 @@ fn aiur_fn_62( let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[61].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[61].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[61].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_61] = unsafe { *(record.function_queries[61].output_at(__i).as_ptr() as *const [G; OUT_61]) }; __ret }, _ => aiur_fn_61(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_62] = [__v_61]; - if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[62].weight(); } record.function_queries[62].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -10335,6 +10398,7 @@ fn aiur_fn_63( unconstrained: bool, ) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -10347,12 +10411,12 @@ fn aiur_fn_63( let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[45].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_11]; - if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[63].weight(); } record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -10369,6 +10433,7 @@ fn aiur_fn_64( unconstrained: bool, ) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -10389,14 +10454,14 @@ fn aiur_fn_64( let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[45].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_64] = [__v_20]; - if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[64].weight(); } record.function_queries[64].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -10413,6 +10478,7 @@ fn aiur_fn_65( unconstrained: bool, ) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -10463,31 +10529,31 @@ fn aiur_fn_65( 0u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[54].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[54].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => aiur_fn_54(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_65] = [__v_49]; - if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[65].weight(); } record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[62].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[62].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[62].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_62] = unsafe { *(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62]) }; __ret }, _ => aiur_fn_62(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_65] = [__v_49]; - if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[65].weight(); } record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[57].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[57].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[57].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => aiur_fn_57(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_65] = [__v_49]; - if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[65].weight(); } record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -10507,9 +10573,10 @@ fn aiur_fn_66( unconstrained: bool, ) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -10560,16 +10627,16 @@ fn aiur_fn_66( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_66] = [__v_1]; - if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_48, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[66].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_50]; - if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -10589,6 +10656,7 @@ fn aiur_fn_67( unconstrained: bool, ) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -10637,59 +10705,59 @@ fn aiur_fn_67( let __v_45: G = inp[45]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[54].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[54].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => aiur_fn_54(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[57].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[57].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[57].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => aiur_fn_57(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } } else { aiur_fn_59(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[59].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[59].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[59].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => aiur_fn_59(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[64].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[64].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[63].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[63].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => aiur_fn_63(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[63].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[63].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => aiur_fn_63(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[63].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[63].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => aiur_fn_63(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -10709,9 +10777,10 @@ fn aiur_fn_68( unconstrained: bool, ) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[756].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[756].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10720,12 +10789,12 @@ fn aiur_fn_68( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[50].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_68] = [__v_11]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -10740,9 +10809,10 @@ fn aiur_fn_69( unconstrained: bool, ) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[756].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[756].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10751,12 +10821,12 @@ fn aiur_fn_69( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[52].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_11]; - if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[69].weight(); } record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -10771,9 +10841,10 @@ fn aiur_fn_70( unconstrained: bool, ) -> Result<[G; OUT_70], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[756].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[756].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10782,12 +10853,12 @@ fn aiur_fn_70( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_11]; - if let Some(result) = record.function_queries[70].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[70].weight(); } record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -10802,6 +10873,7 @@ fn aiur_fn_71( unconstrained: bool, ) -> Result<[G; OUT_71], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -10853,15 +10925,15 @@ fn aiur_fn_71( let __v_48: G = inp[48]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_70(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[70].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[70].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => aiur_fn_70(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_46, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[69].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_45, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_45, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[765].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[765].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[765].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => aiur_fn_765(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -10871,12 +10943,12 @@ fn aiur_fn_71( let __v_58: G = __r_arr[6]; let __v_59: G = __r_arr[7]; let __v_60: G = G::from_u64(12); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_1, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[66].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -10889,12 +10961,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { @@ -10907,12 +10979,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { @@ -10925,12 +10997,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { @@ -10943,12 +11015,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { @@ -10961,12 +11033,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { @@ -10979,12 +11051,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { @@ -10997,12 +11069,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { @@ -11015,12 +11087,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11042,24 +11114,25 @@ fn aiur_fn_72( unconstrained: bool, ) -> Result<[G; OUT_72], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_72] = [__v_2, __v_3]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_72] = [__v_4, __v_7]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11079,6 +11152,7 @@ fn aiur_fn_73( unconstrained: bool, ) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { @@ -11092,11 +11166,11 @@ fn aiur_fn_73( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __ret: [G; OUT_73] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0]; - if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[73].weight(); } record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -11104,7 +11178,7 @@ fn aiur_fn_73( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -11115,7 +11189,7 @@ fn aiur_fn_73( let __v_14: G = __r_arr[7]; let __v_15: G = __r_arr[8]; let __ret: [G; OUT_73] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15]; - if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[73].weight(); } record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11137,8 +11211,9 @@ fn aiur_fn_74( unconstrained: bool, ) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -11181,7 +11256,7 @@ fn aiur_fn_74( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); let __ret: [G; OUT_74] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3]; - if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[74].weight(); } record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11193,7 +11268,7 @@ fn aiur_fn_74( if (__v_33 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("tag0: payload width exceeds 8 bytes".to_string()) }); } - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; @@ -11204,7 +11279,7 @@ fn aiur_fn_74( let __v_42: G = __r_arr[7]; let __v_43: G = __r_arr[8]; let __ret: [G; OUT_74] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; - if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[74].weight(); } record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -11226,8 +11301,9 @@ fn aiur_fn_75( unconstrained: bool, ) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -11267,13 +11343,13 @@ fn aiur_fn_75( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __ret: [G; OUT_75] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; - if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[75].weight(); } record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_26 + __v_27); - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -11290,7 +11366,7 @@ fn aiur_fn_75( return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: Some("tag2: payload width exceeds 8 bytes".to_string()) }); } let __ret: [G; OUT_75] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; - if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[75].weight(); } record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -11312,8 +11388,9 @@ fn aiur_fn_76( unconstrained: bool, ) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -11353,13 +11430,13 @@ fn aiur_fn_76( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __ret: [G; OUT_76] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; - if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[76].weight(); } record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_26 + __v_27); - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -11370,7 +11447,7 @@ fn aiur_fn_76( let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __ret: [G; OUT_76] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; - if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[76].weight(); } record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -11392,6 +11469,7 @@ fn aiur_fn_77( unconstrained: bool, ) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -11401,19 +11479,19 @@ fn aiur_fn_77( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_77] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[77].weight(); } record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -11423,7 +11501,7 @@ fn aiur_fn_77( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -11432,13 +11510,13 @@ fn aiur_fn_77( let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_77] = [__v_30, __v_28]; - if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[77].weight(); } record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11458,6 +11536,7 @@ fn aiur_fn_78( unconstrained: bool, ) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -11468,22 +11547,22 @@ fn aiur_fn_78( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_78] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[78].weight(); } record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -11492,11 +11571,11 @@ fn aiur_fn_78( let __v_21: G = __r_arr[5]; let __v_22: G = __r_arr[6]; let __v_23: G = __r_arr[7]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __ret: [G; OUT_78] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[78].weight(); } record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11516,6 +11595,7 @@ fn aiur_fn_79( unconstrained: bool, ) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -11525,22 +11605,22 @@ fn aiur_fn_79( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_79] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[79].weight(); } record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -11549,14 +11629,14 @@ fn aiur_fn_79( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(8); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_79] = [__v_24, __v_21]; - if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[79].weight(); } record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11576,6 +11656,7 @@ fn aiur_fn_80( unconstrained: bool, ) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -11585,22 +11666,22 @@ fn aiur_fn_80( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_80] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[80].weight(); } record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -11609,14 +11690,14 @@ fn aiur_fn_80( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(9); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_80] = [__v_24, __v_21]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[80].weight(); } record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11636,8 +11717,9 @@ fn aiur_fn_81( unconstrained: bool, ) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -11652,21 +11734,21 @@ fn aiur_fn_81( 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_81] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_81] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11676,18 +11758,18 @@ fn aiur_fn_81( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_81] = [__v_24, __v_21]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11697,18 +11779,18 @@ fn aiur_fn_81( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(3); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_81] = [__v_24, __v_21]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11718,90 +11800,90 @@ fn aiur_fn_81( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(4); - let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_81] = [__v_23, __v_21]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_81] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __v_11: G = G::from_u64(6); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_81] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("App with zero arguments".to_string()) }); } - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_81] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("Lam with zero binders".to_string()) }); } - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_81] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("All with zero binders".to_string()) }); } - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_81] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_81] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 11u64 => { let __v_11: G = G::from_u64(11); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_81] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11821,6 +11903,7 @@ fn aiur_fn_82( unconstrained: bool, ) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -11830,20 +11913,20 @@ fn aiur_fn_82( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(10); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 18] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 18] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_82] = [__v_17, __v_14]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -11858,6 +11941,7 @@ fn aiur_fn_83( unconstrained: bool, ) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -11875,16 +11959,16 @@ fn aiur_fn_83( let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_83] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -11893,7 +11977,7 @@ fn aiur_fn_83( let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -11904,10 +11988,10 @@ fn aiur_fn_83( let __v_33: G = __r_arr[7]; let __v_34: G = __r_arr[8]; let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_37: G = G::from_u64(0); let __ret: [G; OUT_83] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; - if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11927,8 +12011,9 @@ fn aiur_fn_84( unconstrained: bool, ) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -11941,18 +12026,18 @@ fn aiur_fn_84( let __v_10: G = __r_arr[9]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_84] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[84].weight(); } record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -11963,7 +12048,7 @@ fn aiur_fn_84( let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; @@ -11974,7 +12059,7 @@ fn aiur_fn_84( let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; let __ret: [G; OUT_84] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[84].weight(); } record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11983,7 +12068,7 @@ fn aiur_fn_84( } }, 1u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11994,7 +12079,7 @@ fn aiur_fn_84( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -12006,15 +12091,15 @@ fn aiur_fn_84( let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __v_31: G = G::from_u64(2); - let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_34: G = G::from_u64(0); let __ret: [G; OUT_84] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[84].weight(); } record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12025,7 +12110,7 @@ fn aiur_fn_84( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -12037,17 +12122,17 @@ fn aiur_fn_84( let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __v_31: G = G::from_u64(3); - let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_34: G = G::from_u64(0); let __ret: [G; OUT_84] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[84].weight(); } record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_11: G = G::from_u64(4); let __ret: [G; OUT_84] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[84].weight(); } record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -12067,202 +12152,203 @@ fn aiur_fn_85( unconstrained: bool, ) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { - let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_85] = [__v_97, __v_96]; - if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[85].weight(); } record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -12437,6 +12523,7 @@ fn aiur_fn_86( unconstrained: bool, ) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12446,22 +12533,22 @@ fn aiur_fn_86( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_86] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -12470,13 +12557,13 @@ fn aiur_fn_86( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_86] = [__v_23, __v_21]; - if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -12496,6 +12583,7 @@ fn aiur_fn_87( unconstrained: bool, ) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12505,19 +12593,19 @@ fn aiur_fn_87( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_87] = [__v_12, __v_0]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[87].weight(); } record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -12528,7 +12616,7 @@ fn aiur_fn_87( let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = __r_arr[9]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -12537,14 +12625,14 @@ fn aiur_fn_87( let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_87] = [__v_32, __v_29]; - if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[87].weight(); } record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -12564,6 +12652,7 @@ fn aiur_fn_88( unconstrained: bool, ) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12573,22 +12662,22 @@ fn aiur_fn_88( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_88] = [__v_12, __v_0]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[88].weight(); } record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -12597,13 +12686,13 @@ fn aiur_fn_88( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[88].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_88] = [__v_23, __v_21]; - if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[88].weight(); } record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -12623,8 +12712,9 @@ fn aiur_fn_89( unconstrained: bool, ) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12634,11 +12724,11 @@ fn aiur_fn_89( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_89] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[89].weight(); } record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -12653,8 +12743,9 @@ fn aiur_fn_90( unconstrained: bool, ) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12664,11 +12755,11 @@ fn aiur_fn_90( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[88].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_90] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[90].weight(); } record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -12683,8 +12774,9 @@ fn aiur_fn_91( unconstrained: bool, ) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12694,11 +12786,11 @@ fn aiur_fn_91( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_91] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[91].weight(); } record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -12713,69 +12805,70 @@ fn aiur_fn_92( unconstrained: bool, ) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(0); let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(2); let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(0); let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(2); let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(0); let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(2); let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -12795,14 +12888,15 @@ fn aiur_fn_93( unconstrained: bool, ) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[92].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[92].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => aiur_fn_92(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -12812,14 +12906,14 @@ fn aiur_fn_93( let __v_11: G = __r_arr[6]; let __v_12: G = __r_arr[7]; let __v_13: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_93] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17]; - if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -12834,8 +12928,9 @@ fn aiur_fn_94( unconstrained: bool, ) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12845,11 +12940,11 @@ fn aiur_fn_94( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_94] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; - if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[94].weight(); } record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -12864,6 +12959,7 @@ fn aiur_fn_95( unconstrained: bool, ) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12873,19 +12969,19 @@ fn aiur_fn_95( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_95] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[95].weight(); } record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -12895,10 +12991,10 @@ fn aiur_fn_95( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -12907,13 +13003,13 @@ fn aiur_fn_95( let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 11] = [__v_31, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_29]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 11] = [__v_31, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_29]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_95] = [__v_32, __v_30]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[95].weight(); } record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -12933,8 +13029,9 @@ fn aiur_fn_96( unconstrained: bool, ) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; @@ -12946,7 +13043,7 @@ fn aiur_fn_96( let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12956,7 +13053,7 @@ fn aiur_fn_96( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -12966,7 +13063,7 @@ fn aiur_fn_96( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -12976,7 +13073,7 @@ fn aiur_fn_96( let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -12986,7 +13083,7 @@ fn aiur_fn_96( let __v_44: G = __r_arr[6]; let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; @@ -12996,10 +13093,10 @@ fn aiur_fn_96( let __v_53: G = __r_arr[6]; let __v_54: G = __r_arr[7]; let __v_55: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_55]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_57]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -13009,11 +13106,11 @@ fn aiur_fn_96( let __v_64: G = __r_arr[6]; let __v_65: G = __r_arr[7]; let __v_66: G = __r_arr[8]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_96] = [__v_3, __v_4, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_56, __v_67, __v_68]; - if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[96].weight(); } record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -13028,6 +13125,7 @@ fn aiur_fn_97( unconstrained: bool, ) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(2); let __v_2: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_1) } else { bytes2_less_than_value(__v_0, __v_1, record) }; @@ -13036,7 +13134,7 @@ fn aiur_fn_97( return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("Bool byte is not 0 or 1".to_string()) }); } let __ret: [G; OUT_97] = []; - if let Some(result) = record.function_queries[97].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[97].weight(); } record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -13051,12 +13149,13 @@ fn aiur_fn_98( unconstrained: bool, ) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[97].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[97].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[97].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13066,11 +13165,11 @@ fn aiur_fn_98( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_98] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; - if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[98].weight(); } record.function_queries[98].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -13085,30 +13184,31 @@ fn aiur_fn_99( unconstrained: bool, ) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_99] = [__v_1]; - if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[99].weight(); } record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_99] = [__v_1]; - if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[99].weight(); } record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_99] = [__v_1]; - if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[99].weight(); } record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_99] = [__v_1]; - if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[99].weight(); } record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -13128,13 +13228,14 @@ fn aiur_fn_100( unconstrained: bool, ) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[99].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[99].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[99].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => aiur_fn_99(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -13144,11 +13245,11 @@ fn aiur_fn_100( let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_100] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14]; - if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[100].weight(); } record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -13163,12 +13264,13 @@ fn aiur_fn_101( unconstrained: bool, ) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[97].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[97].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[97].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13178,7 +13280,7 @@ fn aiur_fn_101( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -13188,7 +13290,7 @@ fn aiur_fn_101( let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -13198,7 +13300,7 @@ fn aiur_fn_101( let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = __r_arr[2]; @@ -13208,11 +13310,11 @@ fn aiur_fn_101( let __v_36: G = __r_arr[6]; let __v_37: G = __r_arr[7]; let __v_38: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __ret: [G; OUT_101] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40]; - if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[101].weight(); } record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -13227,6 +13329,7 @@ fn aiur_fn_102( unconstrained: bool, ) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -13236,19 +13339,19 @@ fn aiur_fn_102( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_102] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[102].weight(); } record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13284,7 +13387,7 @@ fn aiur_fn_102( let __v_42: G = __r_arr[32]; let __v_43: G = __r_arr[33]; let __v_44: G = __r_arr[34]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; @@ -13293,13 +13396,13 @@ fn aiur_fn_102( let __v_50: G = __r_arr[5]; let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_102] = [__v_56, __v_54]; - if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[102].weight(); } record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -13319,8 +13422,9 @@ fn aiur_fn_103( unconstrained: bool, ) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; @@ -13332,7 +13436,7 @@ fn aiur_fn_103( let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -13342,7 +13446,7 @@ fn aiur_fn_103( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -13352,7 +13456,7 @@ fn aiur_fn_103( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -13362,10 +13466,10 @@ fn aiur_fn_103( let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_39]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; @@ -13375,11 +13479,11 @@ fn aiur_fn_103( let __v_46: G = __r_arr[6]; let __v_47: G = __r_arr[7]; let __v_48: G = __r_arr[8]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_103] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_49, __v_50]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -13394,8 +13498,9 @@ fn aiur_fn_104( unconstrained: bool, ) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13405,11 +13510,11 @@ fn aiur_fn_104( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_104] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; - if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[104].weight(); } record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -13424,8 +13529,9 @@ fn aiur_fn_105( unconstrained: bool, ) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13435,7 +13541,7 @@ fn aiur_fn_105( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13445,11 +13551,11 @@ fn aiur_fn_105( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_105] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20]; - if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[105].weight(); } record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -13464,13 +13570,14 @@ fn aiur_fn_106( unconstrained: bool, ) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_93(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[93].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13487,11 +13594,11 @@ fn aiur_fn_106( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __ret: [G; OUT_106] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15]; - if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[103].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13523,11 +13630,11 @@ fn aiur_fn_106( let __v_31: G = G::from_u64(1); let __v_32: G = G::from_u64(0); let __ret: [G; OUT_106] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30]; - if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[96].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[96].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[96].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13575,7 +13682,7 @@ fn aiur_fn_106( let __v_47: G = __r_arr[44]; let __v_48: G = G::from_u64(2); let __ret: [G; OUT_106] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -13595,6 +13702,7 @@ fn aiur_fn_107( unconstrained: bool, ) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -13604,19 +13712,19 @@ fn aiur_fn_107( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_107] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[107].weight(); } record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[106].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13663,7 +13771,7 @@ fn aiur_fn_107( let __v_53: G = __r_arr[43]; let __v_54: G = __r_arr[44]; let __v_55: G = __r_arr[45]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -13672,13 +13780,13 @@ fn aiur_fn_107( let __v_61: G = __r_arr[5]; let __v_62: G = __r_arr[6]; let __v_63: G = __r_arr[7]; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[107].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_107] = [__v_67, __v_65]; - if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[107].weight(); } record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -13698,11 +13806,12 @@ fn aiur_fn_108( unconstrained: bool, ) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_93(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[93].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13719,11 +13828,11 @@ fn aiur_fn_108( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __ret: [G; OUT_108] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[96].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[96].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[96].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13771,11 +13880,11 @@ fn aiur_fn_108( let __v_46: G = __r_arr[44]; let __v_47: G = G::from_u64(1); let __ret: [G; OUT_108] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13790,11 +13899,11 @@ fn aiur_fn_108( let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); let __ret: [G; OUT_108] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[100].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[100].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[100].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13809,11 +13918,11 @@ fn aiur_fn_108( let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); let __ret: [G; OUT_108] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13835,11 +13944,11 @@ fn aiur_fn_108( let __v_20: G = G::from_u64(4); let __v_21: G = G::from_u64(0); let __ret: [G; OUT_108] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[104].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13853,11 +13962,11 @@ fn aiur_fn_108( let __v_12: G = G::from_u64(5); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_108] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[104].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13871,11 +13980,11 @@ fn aiur_fn_108( let __v_12: G = G::from_u64(6); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_108] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[104].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13889,7 +13998,7 @@ fn aiur_fn_108( let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_108] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -13909,6 +14018,7 @@ fn aiur_fn_109( unconstrained: bool, ) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -13921,13 +14031,13 @@ fn aiur_fn_109( let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { 12u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[107].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(8); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_109] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 13u64 => { @@ -13941,7 +14051,7 @@ fn aiur_fn_109( if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) }); } - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[108].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; @@ -13989,7 +14099,7 @@ fn aiur_fn_109( let __v_61: G = __r_arr[44]; let __v_62: G = __r_arr[45]; let __ret: [G; OUT_109] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14009,8 +14119,9 @@ fn aiur_fn_110( unconstrained: bool, ) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -14023,7 +14134,7 @@ fn aiur_fn_110( let __v_10: G = __r_arr[9]; let __mc_out___mc_0: [G; 46] = '__mc_0: { match __v_1.as_canonical_u64() { 12u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[107].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(8); @@ -14041,7 +14152,7 @@ fn aiur_fn_110( if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) }); } - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[108].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -14141,7 +14252,7 @@ fn aiur_fn_110( let __v_54: G = __mc_out___mc_0[43]; let __v_55: G = __mc_out___mc_0[44]; let __v_56: G = __mc_out___mc_0[45]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_56]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -14151,10 +14262,10 @@ fn aiur_fn_110( let __v_63: G = __r_arr[6]; let __v_64: G = __r_arr[7]; let __v_65: G = __r_arr[8]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_67]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = __r_arr[2]; @@ -14164,10 +14275,10 @@ fn aiur_fn_110( let __v_74: G = __r_arr[6]; let __v_75: G = __r_arr[7]; let __v_76: G = __r_arr[8]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[88].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_78]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = __r_arr[1]; let __v_81: G = __r_arr[2]; @@ -14177,11 +14288,11 @@ fn aiur_fn_110( let __v_85: G = __r_arr[6]; let __v_86: G = __r_arr[7]; let __v_87: G = __r_arr[8]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; let __ret: [G; OUT_110] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_66, __v_77, __v_88, __v_89]; - if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[110].weight(); } record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -14196,29 +14307,30 @@ fn aiur_fn_111( unconstrained: bool, ) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_6, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[753].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_111] = [__v_5, __v_7]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_111] = [__v_0, __v_7]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -14235,8 +14347,9 @@ fn aiur_fn_112( unconstrained: bool, ) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -14260,10 +14373,10 @@ fn aiur_fn_112( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_112] = [__v_23]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -14275,7 +14388,7 @@ fn aiur_fn_112( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -14288,18 +14401,18 @@ fn aiur_fn_112( match __v_27.as_canonical_u64() { 0u64 => { let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_112] = [__v_29]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_112] = [__v_30]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -14321,10 +14434,11 @@ fn aiur_fn_113( unconstrained: bool, ) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -14340,20 +14454,20 @@ fn aiur_fn_113( match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_113] = [__v_1]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_113] = [__v_13]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -14369,20 +14483,20 @@ fn aiur_fn_113( match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_113] = [__v_0]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_113] = [__v_23]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -14399,7 +14513,7 @@ fn aiur_fn_113( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -14411,11 +14525,11 @@ fn aiur_fn_113( let __v_47: G = __r_arr[8]; let __v_48: G = (__v_31 + __v_47); let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[113].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_113] = [__v_51]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14440,13 +14554,14 @@ fn aiur_fn_114( unconstrained: bool, ) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[113].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_3]; - if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[114].weight(); } record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -14461,6 +14576,7 @@ fn aiur_fn_115( unconstrained: bool, ) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -14530,7 +14646,7 @@ fn aiur_fn_115( let __v_51: G = __b2_sub.1; let __v_52: G = (__v_49 + __v_51); let __ret: [G; OUT_115] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; - if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[115].weight(); } record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -14545,10 +14661,11 @@ fn aiur_fn_116( unconstrained: bool, ) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -14561,7 +14678,7 @@ fn aiur_fn_116( let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 1u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -14576,30 +14693,30 @@ fn aiur_fn_116( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_116] = [__v_25, __v_2]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_23.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_116] = [__v_26, __v_2]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_27: G = G::from_u64(1); let __ret: [G; OUT_116] = [__v_26, __v_27]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -14610,7 +14727,7 @@ fn aiur_fn_116( } }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -14627,7 +14744,7 @@ fn aiur_fn_116( 0u64 => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_116] = [__v_0, __v_23]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14639,7 +14756,7 @@ fn aiur_fn_116( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -14651,20 +14768,20 @@ fn aiur_fn_116( let __v_39: G = __r_arr[8]; let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_116] = [__v_46, __v_44]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -14681,7 +14798,7 @@ fn aiur_fn_116( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -14692,13 +14809,13 @@ fn aiur_fn_116( let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = (__v_31 + __v_47); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = G::from_u64(0); - let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_116] = [__v_52, __v_50]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14723,8 +14840,9 @@ fn aiur_fn_117( unconstrained: bool, ) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -14739,9 +14857,9 @@ fn aiur_fn_117( 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_117] = [__v_13]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[117].weight(); } record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -14750,11 +14868,11 @@ fn aiur_fn_117( if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_117] = [__v_13]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[117].weight(); } record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14774,8 +14892,9 @@ fn aiur_fn_118( unconstrained: bool, ) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -14790,15 +14909,15 @@ fn aiur_fn_118( 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_118] = [__v_13]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[118].weight(); } record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -14811,25 +14930,25 @@ fn aiur_fn_118( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_118] = [__v_25]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[118].weight(); } record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_118] = [__v_27]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[118].weight(); } record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14839,9 +14958,9 @@ fn aiur_fn_118( }, _ => { let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_118] = [__v_23]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[118].weight(); } record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -14863,26 +14982,27 @@ fn aiur_fn_119( unconstrained: bool, ) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_119] = [__v_7]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_119] = [__v_5]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14902,11 +15022,12 @@ fn aiur_fn_120( unconstrained: bool, ) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -14921,13 +15042,13 @@ fn aiur_fn_120( 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_120] = [__v_13]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[120].weight(); } record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_120] = [__v_13]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[120].weight(); } record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -14944,6 +15065,7 @@ fn aiur_fn_121( unconstrained: bool, ) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); @@ -14956,12 +15078,12 @@ fn aiur_fn_121( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_121] = [__v_14]; - if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[121].weight(); } record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -14976,6 +15098,7 @@ fn aiur_fn_122( unconstrained: bool, ) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(256); @@ -14983,7 +15106,7 @@ fn aiur_fn_122( match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_122] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[122].weight(); } record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -14991,11 +15114,11 @@ fn aiur_fn_122( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_122] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[122].weight(); } record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -15015,17 +15138,18 @@ fn aiur_fn_123( unconstrained: bool, ) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_123] = [__v_2, __v_5, __v_6]; - if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[123].weight(); } record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -15040,6 +15164,7 @@ fn aiur_fn_124( unconstrained: bool, ) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -15169,7 +15294,7 @@ fn aiur_fn_124( let __v_126: G = (__v_7 * __v_14); let __v_127: G = (__v_125 + __v_126); let __v_128: G = (__v_7 * __v_15); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_16]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = __r_arr[1]; let __v_131: G = __r_arr[2]; @@ -15192,7 +15317,7 @@ fn aiur_fn_124( if (__v_16 != __v_147) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_147.as_canonical_u64(), msg: Some("u64_mul column 0: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_141]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __v_150: G = __r_arr[2]; @@ -15215,7 +15340,7 @@ fn aiur_fn_124( if (__v_141 != __v_166) { return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("u64_mul column 1: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_160]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_167: G = __r_arr[0]; let __v_168: G = __r_arr[1]; let __v_169: G = __r_arr[2]; @@ -15238,7 +15363,7 @@ fn aiur_fn_124( if (__v_160 != __v_185) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("u64_mul column 2: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_179]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __v_188: G = __r_arr[2]; @@ -15261,7 +15386,7 @@ fn aiur_fn_124( if (__v_179 != __v_204) { return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_204.as_canonical_u64(), msg: Some("u64_mul column 3: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_198]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_205: G = __r_arr[0]; let __v_206: G = __r_arr[1]; let __v_207: G = __r_arr[2]; @@ -15284,7 +15409,7 @@ fn aiur_fn_124( if (__v_198 != __v_223) { return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_223.as_canonical_u64(), msg: Some("u64_mul column 4: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_217]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_224: G = __r_arr[0]; let __v_225: G = __r_arr[1]; let __v_226: G = __r_arr[2]; @@ -15307,7 +15432,7 @@ fn aiur_fn_124( if (__v_217 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u64_mul column 5: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_236]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_243: G = __r_arr[0]; let __v_244: G = __r_arr[1]; let __v_245: G = __r_arr[2]; @@ -15330,7 +15455,7 @@ fn aiur_fn_124( if (__v_236 != __v_261) { return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_261.as_canonical_u64(), msg: Some("u64_mul column 6: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_255]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; let __v_263: G = __r_arr[1]; let __v_264: G = __r_arr[2]; @@ -15353,7 +15478,7 @@ fn aiur_fn_124( if (__v_255 != __v_280) { return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_280.as_canonical_u64(), msg: Some("u64_mul column 7: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_274]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_281: G = __r_arr[0]; let __v_282: G = __r_arr[1]; let __v_283: G = __r_arr[2]; @@ -15376,7 +15501,7 @@ fn aiur_fn_124( if (__v_274 != __v_299) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_299.as_canonical_u64(), msg: Some("u64_mul column 8: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_293]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_300: G = __r_arr[0]; let __v_301: G = __r_arr[1]; let __v_302: G = __r_arr[2]; @@ -15399,7 +15524,7 @@ fn aiur_fn_124( if (__v_293 != __v_318) { return Err(ExecError::AssertEqMismatch { lhs: __v_293.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u64_mul column 9: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_312]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_319: G = __r_arr[0]; let __v_320: G = __r_arr[1]; let __v_321: G = __r_arr[2]; @@ -15422,7 +15547,7 @@ fn aiur_fn_124( if (__v_312 != __v_337) { return Err(ExecError::AssertEqMismatch { lhs: __v_312.as_canonical_u64(), rhs: __v_337.as_canonical_u64(), msg: Some("u64_mul column 10: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_331]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_338: G = __r_arr[0]; let __v_339: G = __r_arr[1]; let __v_340: G = __r_arr[2]; @@ -15445,7 +15570,7 @@ fn aiur_fn_124( if (__v_331 != __v_356) { return Err(ExecError::AssertEqMismatch { lhs: __v_331.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: Some("u64_mul column 11: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_350]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_357: G = __r_arr[0]; let __v_358: G = __r_arr[1]; let __v_359: G = __r_arr[2]; @@ -15468,7 +15593,7 @@ fn aiur_fn_124( if (__v_350 != __v_375) { return Err(ExecError::AssertEqMismatch { lhs: __v_350.as_canonical_u64(), rhs: __v_375.as_canonical_u64(), msg: Some("u64_mul column 12: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_369]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_376: G = __r_arr[0]; let __v_377: G = __r_arr[1]; let __v_378: G = __r_arr[2]; @@ -15491,7 +15616,7 @@ fn aiur_fn_124( if (__v_369 != __v_394) { return Err(ExecError::AssertEqMismatch { lhs: __v_369.as_canonical_u64(), rhs: __v_394.as_canonical_u64(), msg: Some("u64_mul column 13: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_388]; let __cu = true; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_395: G = __r_arr[0]; let __v_396: G = __r_arr[1]; let __v_397: G = __r_arr[2]; @@ -15514,7 +15639,7 @@ fn aiur_fn_124( return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u64_mul column 14: split_carry hint does not recompose to the column sum".to_string()) }); } let __ret: [G; OUT_124] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406]; - if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[124].weight(); } record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -15529,16 +15654,17 @@ fn aiur_fn_125( unconstrained: bool, ) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[126].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_125] = [__v_6]; - if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[125].weight(); } record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -15553,11 +15679,12 @@ fn aiur_fn_126( unconstrained: bool, ) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -15571,7 +15698,7 @@ fn aiur_fn_126( match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_126] = [__v_2]; - if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[126].weight(); } record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -15585,19 +15712,19 @@ fn aiur_fn_126( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_25, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[114].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = (__v_3 + __v_28); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[126].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_126] = [__v_30]; - if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[126].weight(); } record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -15617,6 +15744,7 @@ fn aiur_fn_127( unconstrained: bool, ) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -15635,7 +15763,7 @@ fn aiur_fn_127( let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -15648,19 +15776,19 @@ fn aiur_fn_127( let __v_27: G = __loaded[9]; match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_127] = [__v_17]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[127].weight(); } record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[774].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_127] = [__v_29]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[127].weight(); } record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -15669,7 +15797,7 @@ fn aiur_fn_127( } }, 0u64 => { - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[124].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -15686,7 +15814,7 @@ fn aiur_fn_127( let __v_41: G = __r_arr[13]; let __v_42: G = __r_arr[14]; let __v_43: G = __r_arr[15]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -15703,7 +15831,7 @@ fn aiur_fn_127( let __v_57: G = G::from_u64(0); let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __v_62: G = __r_arr[2]; @@ -15713,12 +15841,12 @@ fn aiur_fn_127( let __v_66: G = __r_arr[6]; let __v_67: G = __r_arr[7]; let __v_68: G = __r_arr[8]; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[774].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __ret: [G; OUT_127] = [__v_70]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[127].weight(); } record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -15738,12 +15866,13 @@ fn aiur_fn_128( unconstrained: bool, ) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_128] = [__v_0]; - if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[128].weight(); } record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -15756,13 +15885,13 @@ fn aiur_fn_128( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_128] = [__v_14]; - if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[128].weight(); } record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -15779,10 +15908,11 @@ fn aiur_fn_129( unconstrained: bool, ) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -15797,13 +15927,13 @@ fn aiur_fn_129( 1u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_129] = [__v_12]; - if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[129].weight(); } record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_129] = [__v_12]; - if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[129].weight(); } record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -15820,55 +15950,56 @@ fn aiur_fn_130( unconstrained: bool, ) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __bu_qr: (G, G) = unconstrained_big_uint_div_mod_helper(__v_0, __v_1, record)?; let __v_2: G = __bu_qr.0; let __v_3: G = __bu_qr.1; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[114].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("div/mod hint: q*b + r != a".to_string()) }); } - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("div/mod hint: division by zero must yield a zero quotient".to_string()) }); } let __ret: [G; OUT_130] = [__v_5, __v_7]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[130].weight(); } record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("div/mod hint: remainder is not less than the divisor".to_string()) }); } let __ret: [G; OUT_130] = [__v_5, __v_7]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[130].weight(); } record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -15888,13 +16019,14 @@ fn aiur_fn_131( unconstrained: bool, ) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __ret: [G; OUT_131] = [__v_2]; - if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[131].weight(); } record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -15909,13 +16041,14 @@ fn aiur_fn_132( unconstrained: bool, ) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __ret: [G; OUT_132] = [__v_3]; - if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[132].weight(); } record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -15930,23 +16063,24 @@ fn aiur_fn_133( unconstrained: bool, ) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_133] = [__v_0]; - if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[133].weight(); } record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_133] = [__v_4]; - if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[133].weight(); } record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -15966,9 +16100,10 @@ fn aiur_fn_134( unconstrained: bool, ) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { @@ -15983,10 +16118,10 @@ fn aiur_fn_134( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_134] = [__v_15]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[134].weight(); } record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -16001,32 +16136,32 @@ fn aiur_fn_134( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_134] = [__v_21]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[134].weight(); } record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_23]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[134].weight(); } record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -16051,6 +16186,7 @@ fn aiur_fn_135( unconstrained: bool, ) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -16076,7 +16212,7 @@ fn aiur_fn_135( let __v_22: G = if unconstrained { Bytes2::and(&__v_6, &__v_14) } else { bytes2_and_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { Bytes2::and(&__v_7, &__v_15) } else { bytes2_and_value(__v_7, __v_15, record) }; let __ret: [G; OUT_135] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[135].weight(); } record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16091,6 +16227,7 @@ fn aiur_fn_136( unconstrained: bool, ) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -16116,7 +16253,7 @@ fn aiur_fn_136( let __v_22: G = if unconstrained { Bytes2::or(&__v_6, &__v_14) } else { bytes2_or_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { Bytes2::or(&__v_7, &__v_15) } else { bytes2_or_value(__v_7, __v_15, record) }; let __ret: [G; OUT_136] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[136].weight(); } record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16131,6 +16268,7 @@ fn aiur_fn_137( unconstrained: bool, ) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -16156,7 +16294,7 @@ fn aiur_fn_137( let __v_22: G = if unconstrained { Bytes2::xor(&__v_6, &__v_14) } else { bytes2_xor_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record) }; let __ret: [G; OUT_137] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[137].weight(); } record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16171,9 +16309,10 @@ fn aiur_fn_138( unconstrained: bool, ) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -16188,13 +16327,13 @@ fn aiur_fn_138( 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_138] = [__v_14]; - if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[138].weight(); } record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -16209,14 +16348,14 @@ fn aiur_fn_138( 1u64 => { let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_138] = [__v_24]; - if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[138].weight(); } record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -16225,11 +16364,11 @@ fn aiur_fn_138( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[138].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_138] = [__v_32]; - if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[138].weight(); } record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -16254,9 +16393,10 @@ fn aiur_fn_139( unconstrained: bool, ) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -16270,11 +16410,11 @@ fn aiur_fn_139( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_139] = [__v_1]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -16288,12 +16428,12 @@ fn aiur_fn_139( match __v_12.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_139] = [__v_0]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[136].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -16302,11 +16442,11 @@ fn aiur_fn_139( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[139].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[139].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_139] = [__v_32]; - if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -16331,9 +16471,10 @@ fn aiur_fn_140( unconstrained: bool, ) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -16347,11 +16488,11 @@ fn aiur_fn_140( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_140] = [__v_1]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[140].weight(); } record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -16365,12 +16506,12 @@ fn aiur_fn_140( match __v_12.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_140] = [__v_0]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[140].weight(); } record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[137].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[137].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => aiur_fn_137(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -16379,11 +16520,11 @@ fn aiur_fn_140( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[140].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_140] = [__v_32]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[140].weight(); } record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -16408,6 +16549,7 @@ fn aiur_fn_141( unconstrained: bool, ) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); @@ -16421,14 +16563,14 @@ fn aiur_fn_141( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_16]; - if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[141].weight(); } record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16443,6 +16585,7 @@ fn aiur_fn_142( unconstrained: bool, ) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); @@ -16456,14 +16599,14 @@ fn aiur_fn_142( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_142] = [__v_16]; - if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[142].weight(); } record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16478,6 +16621,7 @@ fn aiur_fn_143( unconstrained: bool, ) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(211); let __v_1: G = G::from_u64(151); let __v_2: G = G::from_u64(55); @@ -16510,9 +16654,9 @@ fn aiur_fn_143( let __v_29: G = G::from_u64(70); let __v_30: G = G::from_u64(125); let __v_31: G = G::from_u64(182); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_143] = [__v_32]; - if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[143].weight(); } record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16527,6 +16671,7 @@ fn aiur_fn_144( unconstrained: bool, ) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(222); let __v_1: G = G::from_u64(245); let __v_2: G = G::from_u64(45); @@ -16559,9 +16704,9 @@ fn aiur_fn_144( let __v_29: G = G::from_u64(186); let __v_30: G = G::from_u64(5); let __v_31: G = G::from_u64(110); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_144] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[144].weight(); } record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16576,6 +16721,7 @@ fn aiur_fn_145( unconstrained: bool, ) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(145); let __v_1: G = G::from_u64(79); let __v_2: G = G::from_u64(156); @@ -16608,9 +16754,9 @@ fn aiur_fn_145( let __v_29: G = G::from_u64(89); let __v_30: G = G::from_u64(76); let __v_31: G = G::from_u64(136); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_145] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[145].weight(); } record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16625,6 +16771,7 @@ fn aiur_fn_146( unconstrained: bool, ) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(9); let __v_1: G = G::from_u64(188); let __v_2: G = G::from_u64(37); @@ -16657,9 +16804,9 @@ fn aiur_fn_146( let __v_29: G = G::from_u64(132); let __v_30: G = G::from_u64(211); let __v_31: G = G::from_u64(220); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_146] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[146].weight(); } record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16674,6 +16821,7 @@ fn aiur_fn_147( unconstrained: bool, ) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(38); let __v_1: G = G::from_u64(124); let __v_2: G = G::from_u64(10); @@ -16706,9 +16854,9 @@ fn aiur_fn_147( let __v_29: G = G::from_u64(241); let __v_30: G = G::from_u64(73); let __v_31: G = G::from_u64(241); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_147] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[147].weight(); } record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16723,6 +16871,7 @@ fn aiur_fn_148( unconstrained: bool, ) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(182); let __v_1: G = G::from_u64(187); let __v_2: G = G::from_u64(172); @@ -16755,9 +16904,9 @@ fn aiur_fn_148( let __v_29: G = G::from_u64(159); let __v_30: G = G::from_u64(233); let __v_31: G = G::from_u64(38); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_148] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[148].weight(); } record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16772,6 +16921,7 @@ fn aiur_fn_149( unconstrained: bool, ) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(188); let __v_1: G = G::from_u64(176); let __v_2: G = G::from_u64(155); @@ -16804,9 +16954,9 @@ fn aiur_fn_149( let __v_29: G = G::from_u64(47); let __v_30: G = G::from_u64(211); let __v_31: G = G::from_u64(137); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_149] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[149].weight(); } record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16821,6 +16971,7 @@ fn aiur_fn_150( unconstrained: bool, ) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(116); let __v_1: G = G::from_u64(237); let __v_2: G = G::from_u64(31); @@ -16853,9 +17004,9 @@ fn aiur_fn_150( let __v_29: G = G::from_u64(220); let __v_30: G = G::from_u64(190); let __v_31: G = G::from_u64(16); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_150] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[150].weight(); } record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16870,6 +17021,7 @@ fn aiur_fn_151( unconstrained: bool, ) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(246); let __v_1: G = G::from_u64(28); let __v_2: G = G::from_u64(125); @@ -16902,9 +17054,9 @@ fn aiur_fn_151( let __v_29: G = G::from_u64(227); let __v_30: G = G::from_u64(78); let __v_31: G = G::from_u64(189); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_151] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[151].weight(); } record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16919,6 +17071,7 @@ fn aiur_fn_152( unconstrained: bool, ) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(172); let __v_1: G = G::from_u64(156); let __v_2: G = G::from_u64(114); @@ -16951,9 +17104,9 @@ fn aiur_fn_152( let __v_29: G = G::from_u64(187); let __v_30: G = G::from_u64(192); let __v_31: G = G::from_u64(112); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_152] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[152].weight(); } record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16968,6 +17121,7 @@ fn aiur_fn_153( unconstrained: bool, ) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(159); let __v_1: G = G::from_u64(44); let __v_2: G = G::from_u64(164); @@ -17000,9 +17154,9 @@ fn aiur_fn_153( let __v_29: G = G::from_u64(242); let __v_30: G = G::from_u64(15); let __v_31: G = G::from_u64(91); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_153] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[153].weight(); } record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17017,6 +17171,7 @@ fn aiur_fn_154( unconstrained: bool, ) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(25); let __v_1: G = G::from_u64(125); let __v_2: G = G::from_u64(60); @@ -17049,9 +17204,9 @@ fn aiur_fn_154( let __v_29: G = G::from_u64(47); let __v_30: G = G::from_u64(66); let __v_31: G = G::from_u64(113); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_154] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[154].weight(); } record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17066,6 +17221,7 @@ fn aiur_fn_155( unconstrained: bool, ) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(7); let __v_1: G = G::from_u64(19); let __v_2: G = G::from_u64(64); @@ -17098,9 +17254,9 @@ fn aiur_fn_155( let __v_29: G = G::from_u64(87); let __v_30: G = G::from_u64(127); let __v_31: G = G::from_u64(87); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_155] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[155].weight(); } record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17115,6 +17271,7 @@ fn aiur_fn_156( unconstrained: bool, ) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(131); let __v_1: G = G::from_u64(227); let __v_2: G = G::from_u64(206); @@ -17147,9 +17304,9 @@ fn aiur_fn_156( let __v_29: G = G::from_u64(173); let __v_30: G = G::from_u64(124); let __v_31: G = G::from_u64(164); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_156] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[156].weight(); } record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17164,6 +17321,7 @@ fn aiur_fn_157( unconstrained: bool, ) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(135); let __v_1: G = G::from_u64(91); let __v_2: G = G::from_u64(232); @@ -17196,9 +17354,9 @@ fn aiur_fn_157( let __v_29: G = G::from_u64(232); let __v_30: G = G::from_u64(76); let __v_31: G = G::from_u64(16); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_157] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[157].weight(); } record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17213,6 +17371,7 @@ fn aiur_fn_158( unconstrained: bool, ) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(225); let __v_1: G = G::from_u64(238); let __v_2: G = G::from_u64(76); @@ -17245,9 +17404,9 @@ fn aiur_fn_158( let __v_29: G = G::from_u64(74); let __v_30: G = G::from_u64(147); let __v_31: G = G::from_u64(229); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_158] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[158].weight(); } record.function_queries[158].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17262,6 +17421,7 @@ fn aiur_fn_159( unconstrained: bool, ) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(191); let __v_1: G = G::from_u64(5); let __v_2: G = G::from_u64(142); @@ -17294,9 +17454,9 @@ fn aiur_fn_159( let __v_29: G = G::from_u64(38); let __v_30: G = G::from_u64(125); let __v_31: G = G::from_u64(87); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_159] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[159].weight(); } record.function_queries[159].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17311,6 +17471,7 @@ fn aiur_fn_160( unconstrained: bool, ) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(194); let __v_1: G = G::from_u64(254); let __v_2: G = G::from_u64(94); @@ -17343,9 +17504,9 @@ fn aiur_fn_160( let __v_29: G = G::from_u64(154); let __v_30: G = G::from_u64(75); let __v_31: G = G::from_u64(7); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_160] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[160].weight(); } record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17360,6 +17521,7 @@ fn aiur_fn_161( unconstrained: bool, ) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(10); let __v_1: G = G::from_u64(236); let __v_2: G = G::from_u64(146); @@ -17392,9 +17554,9 @@ fn aiur_fn_161( let __v_29: G = G::from_u64(185); let __v_30: G = G::from_u64(84); let __v_31: G = G::from_u64(128); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_161] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[161].weight(); } record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17409,6 +17571,7 @@ fn aiur_fn_162( unconstrained: bool, ) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(89); let __v_1: G = G::from_u64(228); let __v_2: G = G::from_u64(125); @@ -17441,9 +17604,9 @@ fn aiur_fn_162( let __v_29: G = G::from_u64(61); let __v_30: G = G::from_u64(206); let __v_31: G = G::from_u64(66); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_162] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[162].weight(); } record.function_queries[162].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17458,6 +17621,7 @@ fn aiur_fn_163( unconstrained: bool, ) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(44); let __v_1: G = G::from_u64(157); let __v_2: G = G::from_u64(45); @@ -17490,9 +17654,9 @@ fn aiur_fn_163( let __v_29: G = G::from_u64(154); let __v_30: G = G::from_u64(171); let __v_31: G = G::from_u64(207); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_163] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[163].weight(); } record.function_queries[163].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17507,6 +17671,7 @@ fn aiur_fn_164( unconstrained: bool, ) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(47); let __v_1: G = G::from_u64(18); let __v_2: G = G::from_u64(243); @@ -17539,9 +17704,9 @@ fn aiur_fn_164( let __v_29: G = G::from_u64(171); let __v_30: G = G::from_u64(113); let __v_31: G = G::from_u64(49); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_164] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[164].weight(); } record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17556,6 +17721,7 @@ fn aiur_fn_165( unconstrained: bool, ) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(131); let __v_1: G = G::from_u64(60); let __v_2: G = G::from_u64(91); @@ -17588,9 +17754,9 @@ fn aiur_fn_165( let __v_29: G = G::from_u64(99); let __v_30: G = G::from_u64(14); let __v_31: G = G::from_u64(52); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_165] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[165].weight(); } record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17605,6 +17771,7 @@ fn aiur_fn_166( unconstrained: bool, ) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(114); let __v_1: G = G::from_u64(50); let __v_2: G = G::from_u64(9); @@ -17637,9 +17804,9 @@ fn aiur_fn_166( let __v_29: G = G::from_u64(175); let __v_30: G = G::from_u64(171); let __v_31: G = G::from_u64(154); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_166] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[166].weight(); } record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17654,6 +17821,7 @@ fn aiur_fn_167( unconstrained: bool, ) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(195); let __v_1: G = G::from_u64(176); let __v_2: G = G::from_u64(11); @@ -17686,9 +17854,9 @@ fn aiur_fn_167( let __v_29: G = G::from_u64(58); let __v_30: G = G::from_u64(4); let __v_31: G = G::from_u64(240); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_167] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[167].weight(); } record.function_queries[167].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17703,6 +17871,7 @@ fn aiur_fn_168( unconstrained: bool, ) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(110); let __v_1: G = G::from_u64(112); let __v_2: G = G::from_u64(205); @@ -17735,9 +17904,9 @@ fn aiur_fn_168( let __v_29: G = G::from_u64(255); let __v_30: G = G::from_u64(9); let __v_31: G = G::from_u64(120); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_168] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[168].weight(); } record.function_queries[168].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17752,6 +17921,7 @@ fn aiur_fn_169( unconstrained: bool, ) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(216); let __v_1: G = G::from_u64(221); let __v_2: G = G::from_u64(236); @@ -17784,9 +17954,9 @@ fn aiur_fn_169( let __v_29: G = G::from_u64(52); let __v_30: G = G::from_u64(249); let __v_31: G = G::from_u64(243); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_169] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[169].weight(); } record.function_queries[169].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17801,6 +17971,7 @@ fn aiur_fn_170( unconstrained: bool, ) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(202); let __v_1: G = G::from_u64(48); let __v_2: G = G::from_u64(34); @@ -17833,9 +18004,9 @@ fn aiur_fn_170( let __v_29: G = G::from_u64(17); let __v_30: G = G::from_u64(32); let __v_31: G = G::from_u64(112); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_170] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17850,6 +18021,7 @@ fn aiur_fn_171( unconstrained: bool, ) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(202); let __v_1: G = G::from_u64(75); let __v_2: G = G::from_u64(57); @@ -17882,9 +18054,9 @@ fn aiur_fn_171( let __v_29: G = G::from_u64(27); let __v_30: G = G::from_u64(28); let __v_31: G = G::from_u64(188); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_171] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[171].weight(); } record.function_queries[171].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17899,6 +18071,7 @@ fn aiur_fn_172( unconstrained: bool, ) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(162); let __v_1: G = G::from_u64(154); let __v_2: G = G::from_u64(99); @@ -17931,9 +18104,9 @@ fn aiur_fn_172( let __v_29: G = G::from_u64(240); let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(98); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_172] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[172].weight(); } record.function_queries[172].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17948,6 +18121,7 @@ fn aiur_fn_173( unconstrained: bool, ) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(221); let __v_1: G = G::from_u64(161); let __v_2: G = G::from_u64(43); @@ -17980,9 +18154,9 @@ fn aiur_fn_173( let __v_29: G = G::from_u64(244); let __v_30: G = G::from_u64(198); let __v_31: G = G::from_u64(62); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_173] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[173].weight(); } record.function_queries[173].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -17997,6 +18171,7 @@ fn aiur_fn_174( unconstrained: bool, ) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(169); let __v_1: G = G::from_u64(22); let __v_2: G = G::from_u64(36); @@ -18029,9 +18204,9 @@ fn aiur_fn_174( let __v_29: G = G::from_u64(188); let __v_30: G = G::from_u64(250); let __v_31: G = G::from_u64(236); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_174] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[174].weight(); } record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18046,6 +18221,7 @@ fn aiur_fn_175( unconstrained: bool, ) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(123); let __v_1: G = G::from_u64(216); let __v_2: G = G::from_u64(225); @@ -18078,9 +18254,9 @@ fn aiur_fn_175( let __v_29: G = G::from_u64(127); let __v_30: G = G::from_u64(64); let __v_31: G = G::from_u64(18); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_175] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[175].weight(); } record.function_queries[175].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18095,6 +18271,7 @@ fn aiur_fn_176( unconstrained: bool, ) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(28); let __v_1: G = G::from_u64(23); let __v_2: G = G::from_u64(0); @@ -18127,9 +18304,9 @@ fn aiur_fn_176( let __v_29: G = G::from_u64(169); let __v_30: G = G::from_u64(250); let __v_31: G = G::from_u64(120); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_176] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[176].weight(); } record.function_queries[176].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18144,6 +18321,7 @@ fn aiur_fn_177( unconstrained: bool, ) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(22); let __v_1: G = G::from_u64(133); let __v_2: G = G::from_u64(48); @@ -18176,9 +18354,9 @@ fn aiur_fn_177( let __v_29: G = G::from_u64(40); let __v_30: G = G::from_u64(229); let __v_31: G = G::from_u64(96); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_177] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[177].weight(); } record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18193,6 +18371,7 @@ fn aiur_fn_178( unconstrained: bool, ) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(12); let __v_1: G = G::from_u64(112); let __v_2: G = G::from_u64(114); @@ -18225,9 +18404,9 @@ fn aiur_fn_178( let __v_29: G = G::from_u64(227); let __v_30: G = G::from_u64(108); let __v_31: G = G::from_u64(113); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_178] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18242,6 +18421,7 @@ fn aiur_fn_179( unconstrained: bool, ) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(102); let __v_1: G = G::from_u64(242); let __v_2: G = G::from_u64(155); @@ -18274,9 +18454,9 @@ fn aiur_fn_179( let __v_29: G = G::from_u64(176); let __v_30: G = G::from_u64(189); let __v_31: G = G::from_u64(213); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_179] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[179].weight(); } record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18291,70 +18471,71 @@ fn aiur_fn_180( unconstrained: bool, ) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[174].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_180] = [__v_3]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[180].weight(); } record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; let __hit = record.function_queries[175].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[175].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_180] = [__v_5]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[180].weight(); } record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; let __hit = record.function_queries[176].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_180] = [__v_7]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[180].weight(); } record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_180] = [__v_9]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[180].weight(); } record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[178].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_180] = [__v_11]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[180].weight(); } record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_180] = [__v_11]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[180].weight(); } record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -18379,6 +18560,7 @@ fn aiur_fn_181( unconstrained: bool, ) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(64); let __v_2: G = G::from_u64(0); @@ -18390,14 +18572,14 @@ fn aiur_fn_181( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_181] = [__v_16]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[181].weight(); } record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18412,6 +18594,7 @@ fn aiur_fn_182( unconstrained: bool, ) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(0); @@ -18423,14 +18606,14 @@ fn aiur_fn_182( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_182] = [__v_16]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[182].weight(); } record.function_queries[182].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18445,58 +18628,59 @@ fn aiur_fn_183( unconstrained: bool, ) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[174].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; let __hit = record.function_queries[181].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[181].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_183] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[183].weight(); } record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; let __hit = record.function_queries[175].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[175].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; let __hit = record.function_queries[182].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_183] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[183].weight(); } record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[178].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[184].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[184].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_183] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[183].weight(); } record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; let __hit = record.function_queries[176].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_10 + __v_12); match __v_13.as_canonical_u64() { @@ -18505,13 +18689,13 @@ fn aiur_fn_183( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_183] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[183].weight(); } record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -18521,32 +18705,32 @@ fn aiur_fn_183( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_183] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[183].weight(); } record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_18, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __ret: [G; OUT_183] = [__v_20, __v_21]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[183].weight(); } record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[186].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __ret: [G; OUT_183] = [__v_20, __v_21]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[183].weight(); } record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -18573,8 +18757,9 @@ fn aiur_fn_184( unconstrained: bool, ) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -18584,36 +18769,36 @@ fn aiur_fn_184( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_184] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; let __hit = record.function_queries[179].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[179].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[179].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; let __hit = record.function_queries[181].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[181].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_184] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -18621,9 +18806,9 @@ fn aiur_fn_184( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_184] = [__v_14, __v_18]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -18633,9 +18818,9 @@ fn aiur_fn_184( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_184] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -18654,21 +18839,22 @@ fn aiur_fn_185( unconstrained: bool, ) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[172].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_6 + __v_8); match __v_9.as_canonical_u64() { @@ -18677,15 +18863,15 @@ fn aiur_fn_185( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_185] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_185] = [__v_10, __v_0]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -18695,9 +18881,9 @@ fn aiur_fn_185( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_185] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -18714,8 +18900,9 @@ fn aiur_fn_186( unconstrained: bool, ) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -18726,7 +18913,7 @@ fn aiur_fn_186( 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_186] = [__v_5, __v_0]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -18734,9 +18921,9 @@ fn aiur_fn_186( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_186] = [__v_5, __v_9]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -18746,9 +18933,9 @@ fn aiur_fn_186( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_186] = [__v_5, __v_9]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -18765,6 +18952,7 @@ fn aiur_fn_187( unconstrained: bool, ) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(227); let __v_1: G = G::from_u64(42); let __v_2: G = G::from_u64(180); @@ -18797,9 +18985,9 @@ fn aiur_fn_187( let __v_29: G = G::from_u64(82); let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(116); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_187] = [__v_32]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[187].weight(); } record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18814,6 +19002,7 @@ fn aiur_fn_188( unconstrained: bool, ) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(59); let __v_1: G = G::from_u64(51); let __v_2: G = G::from_u64(76); @@ -18846,9 +19035,9 @@ fn aiur_fn_188( let __v_29: G = G::from_u64(189); let __v_30: G = G::from_u64(191); let __v_31: G = G::from_u64(110); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_188] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[188].weight(); } record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18863,6 +19052,7 @@ fn aiur_fn_189( unconstrained: bool, ) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(103); let __v_1: G = G::from_u64(244); let __v_2: G = G::from_u64(116); @@ -18895,9 +19085,9 @@ fn aiur_fn_189( let __v_29: G = G::from_u64(135); let __v_30: G = G::from_u64(43); let __v_31: G = G::from_u64(164); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_189] = [__v_32]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[189].weight(); } record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18912,6 +19102,7 @@ fn aiur_fn_190( unconstrained: bool, ) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(79); let __v_1: G = G::from_u64(157); let __v_2: G = G::from_u64(78); @@ -18944,9 +19135,9 @@ fn aiur_fn_190( let __v_29: G = G::from_u64(144); let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(204); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_190] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[190].weight(); } record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18961,6 +19152,7 @@ fn aiur_fn_191( unconstrained: bool, ) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(197); let __v_1: G = G::from_u64(247); let __v_2: G = G::from_u64(177); @@ -18993,9 +19185,9 @@ fn aiur_fn_191( let __v_29: G = G::from_u64(115); let __v_30: G = G::from_u64(55); let __v_31: G = G::from_u64(35); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_191] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[191].weight(); } record.function_queries[191].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -19010,6 +19202,7 @@ fn aiur_fn_192( unconstrained: bool, ) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(202); let __v_1: G = G::from_u64(202); let __v_2: G = G::from_u64(234); @@ -19042,9 +19235,9 @@ fn aiur_fn_192( let __v_29: G = G::from_u64(61); let __v_30: G = G::from_u64(51); let __v_31: G = G::from_u64(18); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_192] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[192].weight(); } record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -19059,46 +19252,47 @@ fn aiur_fn_193( unconstrained: bool, ) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; let __hit = record.function_queries[187].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_193] = [__v_3]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[190].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_193] = [__v_5]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; let __hit = record.function_queries[191].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[191].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[191].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_193] = [__v_7]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_193] = [__v_7]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -19119,32 +19313,33 @@ fn aiur_fn_194( unconstrained: bool, ) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(2); - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_194] = [__v_7]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[172].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_194] = [__v_7]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -19161,9 +19356,10 @@ fn aiur_fn_195( unconstrained: bool, ) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -19172,13 +19368,13 @@ fn aiur_fn_195( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_195] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[195].weight(); } record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -19186,13 +19382,13 @@ fn aiur_fn_195( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_195] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[195].weight(); } record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { @@ -19200,9 +19396,9 @@ fn aiur_fn_195( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_195] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[195].weight(); } record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { @@ -19217,17 +19413,17 @@ fn aiur_fn_195( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_21, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_21, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_6, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_195] = [__v_23, __v_25]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[195].weight(); } record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19257,8 +19453,9 @@ fn aiur_fn_196( unconstrained: bool, ) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19268,22 +19465,22 @@ fn aiur_fn_196( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_196] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[195].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { @@ -19292,13 +19489,13 @@ fn aiur_fn_196( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_196] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[195].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -19307,21 +19504,21 @@ fn aiur_fn_196( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_196] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 - __v_15); let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_196] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19348,8 +19545,9 @@ fn aiur_fn_197( unconstrained: bool, ) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(2); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19359,28 +19557,28 @@ fn aiur_fn_197( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_197] = [__v_4, __v_8]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { @@ -19388,13 +19586,13 @@ fn aiur_fn_197( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_197] = [__v_14, __v_18]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19404,28 +19602,28 @@ fn aiur_fn_197( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_197] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; let __v_22: G = __loaded[1]; let __v_23: G = __loaded[2]; let __v_24: G = __loaded[3]; match __v_21.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; let __cu = unconstrained; let __hit = record.function_queries[189].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[189].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_189] = unsafe { *(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189]) }; __ret }, _ => aiur_fn_189(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_22, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 0u64 => { @@ -19433,13 +19631,13 @@ fn aiur_fn_197( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_197] = [__v_27, __v_31]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = { let __a_val = __v_27.as_canonical_u64(); let __b_val = __v_28.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19449,35 +19647,35 @@ fn aiur_fn_197( let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_197] = [__v_30, __v_34]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_20, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(3); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = G::from_u64(1); - let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __ret: [G; OUT_197] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -19489,9 +19687,9 @@ fn aiur_fn_197( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_197] = [__v_25, __v_29]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -19505,9 +19703,9 @@ fn aiur_fn_197( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_197] = [__v_12, __v_16]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -19526,24 +19724,25 @@ fn aiur_fn_198( unconstrained: bool, ) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[188].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(2); let __v_11: G = (__v_9 - __v_10); @@ -19551,13 +19750,13 @@ fn aiur_fn_198( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_198] = [__v_12, __v_14, __v_16]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19565,13 +19764,13 @@ fn aiur_fn_198( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_198] = [__v_12, __v_16, __v_20]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -19581,13 +19780,13 @@ fn aiur_fn_198( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_198] = [__v_9, __v_13, __v_17]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -19597,13 +19796,13 @@ fn aiur_fn_198( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_198] = [__v_7, __v_11, __v_15]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -19620,16 +19819,17 @@ fn aiur_fn_199( unconstrained: bool, ) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; let __hit = record.function_queries[187].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(2); let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19639,21 +19839,21 @@ fn aiur_fn_199( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_199] = [__v_8, __v_12]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[386].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[386].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[386].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[195].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -19662,17 +19862,17 @@ fn aiur_fn_199( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_199] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_199] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19683,33 +19883,33 @@ fn aiur_fn_199( } }, _ => { - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[190].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_199] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; let __hit = record.function_queries[191].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[191].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[191].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_199] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19717,9 +19917,9 @@ fn aiur_fn_199( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_199] = [__v_9, __v_13]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -19740,55 +19940,56 @@ fn aiur_fn_200( unconstrained: bool, ) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_200] = [__v_2]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_200] = [__v_2]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_200] = [__v_2]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_200] = [__v_19]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19818,17 +20019,18 @@ fn aiur_fn_201( unconstrained: bool, ) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_201] = [__v_5]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -19843,6 +20045,7 @@ fn aiur_fn_202( unconstrained: bool, ) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(81); let __v_1: G = G::from_u64(134); let __v_2: G = G::from_u64(217); @@ -19875,9 +20078,9 @@ fn aiur_fn_202( let __v_29: G = G::from_u64(158); let __v_30: G = G::from_u64(90); let __v_31: G = G::from_u64(110); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_202] = [__v_32]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[202].weight(); } record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -19892,6 +20095,7 @@ fn aiur_fn_203( unconstrained: bool, ) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(255); let __v_1: G = G::from_u64(69); let __v_2: G = G::from_u64(149); @@ -19924,9 +20128,9 @@ fn aiur_fn_203( let __v_29: G = G::from_u64(29); let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(158); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_203] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[203].weight(); } record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -19941,6 +20145,7 @@ fn aiur_fn_204( unconstrained: bool, ) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(15); let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(80); @@ -19973,9 +20178,9 @@ fn aiur_fn_204( let __v_29: G = G::from_u64(129); let __v_30: G = G::from_u64(40); let __v_31: G = G::from_u64(217); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_204] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[204].weight(); } record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -19990,6 +20195,7 @@ fn aiur_fn_205( unconstrained: bool, ) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(9); let __v_1: G = G::from_u64(238); let __v_2: G = G::from_u64(180); @@ -20022,9 +20228,9 @@ fn aiur_fn_205( let __v_29: G = G::from_u64(203); let __v_30: G = G::from_u64(141); let __v_31: G = G::from_u64(52); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_205] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[205].weight(); } record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -20039,6 +20245,7 @@ fn aiur_fn_206( unconstrained: bool, ) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(37); let __v_1: G = G::from_u64(138); let __v_2: G = G::from_u64(115); @@ -20071,9 +20278,9 @@ fn aiur_fn_206( let __v_29: G = G::from_u64(239); let __v_30: G = G::from_u64(202); let __v_31: G = G::from_u64(62); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_206] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[206].weight(); } record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -20088,6 +20295,7 @@ fn aiur_fn_207( unconstrained: bool, ) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(119); let __v_1: G = G::from_u64(213); let __v_2: G = G::from_u64(25); @@ -20120,9 +20328,9 @@ fn aiur_fn_207( let __v_29: G = G::from_u64(53); let __v_30: G = G::from_u64(2); let __v_31: G = G::from_u64(160); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_207] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[207].weight(); } record.function_queries[207].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -20137,6 +20345,7 @@ fn aiur_fn_208( unconstrained: bool, ) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(32); let __v_1: G = G::from_u64(59); let __v_2: G = G::from_u64(118); @@ -20169,9 +20378,9 @@ fn aiur_fn_208( let __v_29: G = G::from_u64(250); let __v_30: G = G::from_u64(110); let __v_31: G = G::from_u64(238); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_208] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[208].weight(); } record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -20186,6 +20395,7 @@ fn aiur_fn_209( unconstrained: bool, ) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(84); let __v_1: G = G::from_u64(139); let __v_2: G = G::from_u64(191); @@ -20218,9 +20428,9 @@ fn aiur_fn_209( let __v_29: G = G::from_u64(210); let __v_30: G = G::from_u64(29); let __v_31: G = G::from_u64(101); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_209] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[209].weight(); } record.function_queries[209].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -20235,6 +20445,7 @@ fn aiur_fn_210( unconstrained: bool, ) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(239); let __v_1: G = G::from_u64(78); let __v_2: G = G::from_u64(116); @@ -20267,9 +20478,9 @@ fn aiur_fn_210( let __v_29: G = G::from_u64(206); let __v_30: G = G::from_u64(253); let __v_31: G = G::from_u64(201); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_210] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[210].weight(); } record.function_queries[210].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -20284,6 +20495,7 @@ fn aiur_fn_211( unconstrained: bool, ) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(135); let __v_1: G = G::from_u64(9); let __v_2: G = G::from_u64(245); @@ -20316,9 +20528,9 @@ fn aiur_fn_211( let __v_29: G = G::from_u64(74); let __v_30: G = G::from_u64(12); let __v_31: G = G::from_u64(41); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_211] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[211].weight(); } record.function_queries[211].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -20333,6 +20545,7 @@ fn aiur_fn_212( unconstrained: bool, ) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(13); let __v_1: G = G::from_u64(35); let __v_2: G = G::from_u64(99); @@ -20365,9 +20578,9 @@ fn aiur_fn_212( let __v_29: G = G::from_u64(221); let __v_30: G = G::from_u64(226); let __v_31: G = G::from_u64(34); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_212] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -20382,6 +20595,7 @@ fn aiur_fn_213( unconstrained: bool, ) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(20); let __v_1: G = G::from_u64(207); let __v_2: G = G::from_u64(81); @@ -20414,9 +20628,9 @@ fn aiur_fn_213( let __v_29: G = G::from_u64(39); let __v_30: G = G::from_u64(229); let __v_31: G = G::from_u64(107); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_213] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[213].weight(); } record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -20431,6 +20645,7 @@ fn aiur_fn_214( unconstrained: bool, ) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(253); let __v_1: G = G::from_u64(83); let __v_2: G = G::from_u64(232); @@ -20463,9 +20678,9 @@ fn aiur_fn_214( let __v_29: G = G::from_u64(75); let __v_30: G = G::from_u64(101); let __v_31: G = G::from_u64(135); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_214] = [__v_32]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[214].weight(); } record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -20480,94 +20695,95 @@ fn aiur_fn_215( unconstrained: bool, ) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[202].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_215] = [__v_3]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_215] = [__v_5]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_215] = [__v_7]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_215] = [__v_9]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[210].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_215] = [__v_11]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; let __hit = record.function_queries[211].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[211].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_215] = [__v_13]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[213].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __ret: [G; OUT_215] = [__v_15]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_215] = [__v_15]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -20596,23 +20812,24 @@ fn aiur_fn_216( unconstrained: bool, ) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -20621,9 +20838,9 @@ fn aiur_fn_216( let __v_11: G = G::from_u64(7); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -20631,9 +20848,9 @@ fn aiur_fn_216( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -20646,17 +20863,17 @@ fn aiur_fn_216( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[202].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { @@ -20668,16 +20885,16 @@ fn aiur_fn_216( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -20686,17 +20903,17 @@ fn aiur_fn_216( 7u64 => { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[229].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(7); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -20704,9 +20921,9 @@ fn aiur_fn_216( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -20716,9 +20933,9 @@ fn aiur_fn_216( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -20726,65 +20943,65 @@ fn aiur_fn_216( } }, _ => { - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[217].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[217].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_216] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[210].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[217].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[217].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_216] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; let __hit = record.function_queries[211].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[211].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[218].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_216] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[213].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_521(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[521].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[521].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[521].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_521] = unsafe { *(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521]) }; __ret }, _ => aiur_fn_521(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_216] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { @@ -20796,19 +21013,19 @@ fn aiur_fn_216( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_20, __v_24]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; @@ -20817,7 +21034,7 @@ fn aiur_fn_216( 7u64 => { match __v_25.as_canonical_u64() { 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; @@ -20826,15 +21043,15 @@ fn aiur_fn_216( 7u64 => { match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_26, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(7); let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_33, __v_37]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -20842,9 +21059,9 @@ fn aiur_fn_216( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); - let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_32, __v_36]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -20854,9 +21071,9 @@ fn aiur_fn_216( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); - let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_32, __v_36]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -20866,9 +21083,9 @@ fn aiur_fn_216( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_28, __v_32]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -20878,9 +21095,9 @@ fn aiur_fn_216( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_28, __v_32]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -20892,9 +21109,9 @@ fn aiur_fn_216( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_216] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -20923,8 +21140,9 @@ fn aiur_fn_217( unconstrained: bool, ) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -20934,16 +21152,16 @@ fn aiur_fn_217( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_217] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -20952,28 +21170,28 @@ fn aiur_fn_217( 7u64 => { match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[229].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_16: G = G::from_u64(2); - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; let __hit = record.function_queries[205].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[205].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_16, __v_17, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 4] = [__v_16, __v_17, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(3); let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_217] = [__v_23, __v_26]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -20981,9 +21199,9 @@ fn aiur_fn_217( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_217] = [__v_10, __v_14]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -20993,9 +21211,9 @@ fn aiur_fn_217( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_217] = [__v_10, __v_14]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -21014,8 +21232,9 @@ fn aiur_fn_218( unconstrained: bool, ) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -21025,16 +21244,16 @@ fn aiur_fn_218( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_218] = [__v_4, __v_8]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[218].weight(); } record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -21043,7 +21262,7 @@ fn aiur_fn_218( 7u64 => { match __v_7.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -21051,15 +21270,15 @@ fn aiur_fn_218( 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(2); - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; let __hit = record.function_queries[212].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[212].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[212].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_212] = unsafe { *(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212]) }; __ret }, _ => aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_218] = [__v_13, __v_20]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[218].weight(); } record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -21067,9 +21286,9 @@ fn aiur_fn_218( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_218] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[218].weight(); } record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -21079,9 +21298,9 @@ fn aiur_fn_218( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_218] = [__v_10, __v_14]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[218].weight(); } record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -21091,9 +21310,9 @@ fn aiur_fn_218( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_218] = [__v_10, __v_14]; - if 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)); }; + if !unconstrained { record.virt += record.function_queries[218].weight(); } record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -21112,24 +21331,25 @@ fn aiur_fn_219( unconstrained: bool, ) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_219] = []; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[219].weight(); } record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_219] = []; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[219].weight(); } record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -21149,12 +21369,13 @@ fn aiur_fn_220( unconstrained: bool, ) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(65); - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[221].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __ret: [G; OUT_220] = [__v_2]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[220].weight(); } record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -21169,26 +21390,27 @@ fn aiur_fn_221( unconstrained: bool, ) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_221] = [__v_1]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[221].weight(); } record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[221].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_221] = [__v_7]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[221].weight(); } record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -21208,6 +21430,7 @@ fn aiur_fn_222( unconstrained: bool, ) -> Result<[G; OUT_222], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(128); let __v_2: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_1) } else { bytes2_less_than_value(__v_0, __v_1, record) }; @@ -21220,7 +21443,7 @@ fn aiur_fn_222( let __v_5: G = G::from_u64(128); let __v_6: G = (__v_0 - __v_5); let __ret: [G; OUT_222] = [__v_6]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -21245,6 +21468,7 @@ fn aiur_fn_223( unconstrained: bool, ) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(128); @@ -21252,7 +21476,7 @@ fn aiur_fn_223( match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_223] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -21264,7 +21488,7 @@ fn aiur_fn_223( let __v_7: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_6) } else { bytes2_less_than_value(__v_0, __v_6, record) }; match __v_7.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -21274,11 +21498,11 @@ fn aiur_fn_223( let __v_12: G = (__v_0 - __v_11); let __v_13: G = G::from_u64(64); let __v_14: G = (__v_12 * __v_13); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 + __v_15); let __ret: [G; OUT_223] = [__v_16, __v_10]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -21291,13 +21515,13 @@ fn aiur_fn_223( let __v_9: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_8) } else { bytes2_less_than_value(__v_0, __v_8, record) }; match __v_9.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -21307,11 +21531,11 @@ fn aiur_fn_223( let __v_17: G = (__v_0 - __v_16); let __v_18: G = G::from_u64(4096); let __v_19: G = (__v_17 * __v_18); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(64); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_22 + __v_23); let __v_25: G = (__v_19 + __v_24); @@ -21320,7 +21544,7 @@ fn aiur_fn_223( match __v_27.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_223] = [__v_25, __v_15]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -21339,19 +21563,19 @@ fn aiur_fn_223( } }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; @@ -21361,15 +21585,15 @@ fn aiur_fn_223( let __v_20: G = (__v_0 - __v_19); let __v_21: G = G::from_u64(262144); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(4096); let __v_25: G = (__v_23 * __v_24); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(64); let __v_28: G = (__v_26 * __v_27); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_28 + __v_29); let __v_31: G = (__v_25 + __v_30); @@ -21379,7 +21603,7 @@ fn aiur_fn_223( match __v_34.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_223] = [__v_32, __v_18]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -21425,62 +21649,63 @@ fn aiur_fn_224( unconstrained: bool, ) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(0); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_9: G = G::from_u64(2); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[207].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[208].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; let __hit = record.function_queries[205].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[205].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_31: G = G::from_u64(2); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_31, __v_32, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 4] = [__v_31, __v_32, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_38: G = G::from_u64(3); let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 4] = [__v_38, __v_12, __v_23, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 4] = [__v_38, __v_12, __v_23, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[225].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(3); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_224] = [__v_47]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -21495,43 +21720,44 @@ fn aiur_fn_225( unconstrained: bool, ) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_225] = [__v_1]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[225].weight(); } record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[229].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(7); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_17: G = G::from_u64(3); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[225].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_225] = [__v_23]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[225].weight(); } record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -21551,25 +21777,26 @@ fn aiur_fn_226( unconstrained: bool, ) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -21586,10 +21813,10 @@ fn aiur_fn_226( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_14, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; let __v_28: G = __loaded[1]; let __v_29: G = __loaded[2]; @@ -21597,43 +21824,43 @@ fn aiur_fn_226( match __v_27.as_canonical_u64() { 4u64 => { let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_32, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __ret: [G; OUT_226] = [__v_33]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[226].weight(); } record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_33, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_226] = [__v_34]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[226].weight(); } record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_226] = [__v_0]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[226].weight(); } record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_226] = [__v_0]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[226].weight(); } record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_226] = [__v_0]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[226].weight(); } record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -21650,9 +21877,10 @@ fn aiur_fn_227( unconstrained: bool, ) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -21661,24 +21889,24 @@ fn aiur_fn_227( 7u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[224].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[224].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_224] = unsafe { *(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224]) }; __ret }, _ => aiur_fn_224(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[226].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_227] = [__v_7]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[227].weight(); } record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_227] = [__v_0]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[227].weight(); } record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_227] = [__v_0]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[227].weight(); } record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -21695,25 +21923,26 @@ fn aiur_fn_228( unconstrained: bool, ) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_228] = [__v_2, __v_5, __v_8, __v_11]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[228].weight(); } record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -21728,8 +21957,9 @@ fn aiur_fn_229( unconstrained: bool, ) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; let __cu = true; let __hit = record.function_queries[228].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -21761,12 +21991,12 @@ fn aiur_fn_229( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_229] = [__v_31]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[229].weight(); } record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -21781,73 +22011,74 @@ fn aiur_fn_230( unconstrained: bool, ) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_230] = [__v_12, __v_15]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[230].weight(); } record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_230] = [__v_12, __v_15]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[230].weight(); } record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[207].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_230] = [__v_13, __v_16]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[230].weight(); } record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 3u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[231].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { @@ -21855,31 +22086,31 @@ fn aiur_fn_230( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_230] = [__v_18, __v_21]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[230].weight(); } record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_18: G = G::from_u64(2); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_19, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_230] = [__v_22, __v_21]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[230].weight(); } record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_17, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_230] = [__v_22, __v_23]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[230].weight(); } record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -21896,9 +22127,9 @@ fn aiur_fn_230( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_230] = [__v_14, __v_17]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[230].weight(); } record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -21911,9 +22142,9 @@ fn aiur_fn_230( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_230] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[230].weight(); } record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -21930,26 +22161,27 @@ fn aiur_fn_231( unconstrained: bool, ) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_231] = [__v_4, __v_3]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[231].weight(); } record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_231] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[231].weight(); } record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -21966,35 +22198,36 @@ fn aiur_fn_232( unconstrained: bool, ) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; let __hit = record.function_queries[205].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[205].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __ret: [G; OUT_232] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[232].weight(); } record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -22003,18 +22236,18 @@ fn aiur_fn_232( 7u64 => { match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[233].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_232] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[232].weight(); } record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __ret: [G; OUT_232] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[232].weight(); } record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22023,7 +22256,7 @@ fn aiur_fn_232( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __ret: [G; OUT_232] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[232].weight(); } record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22034,7 +22267,7 @@ fn aiur_fn_232( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __ret: [G; OUT_232] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[232].weight(); } record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22043,7 +22276,7 @@ fn aiur_fn_232( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __ret: [G; OUT_232] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[232].weight(); } record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22060,8 +22293,9 @@ fn aiur_fn_233( unconstrained: bool, ) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -22074,7 +22308,7 @@ fn aiur_fn_233( let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -22097,7 +22331,7 @@ fn aiur_fn_233( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); let __ret: [G; OUT_233] = [__v_26, __v_27]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -22113,7 +22347,7 @@ fn aiur_fn_233( 1u64 => { let __v_34: G = G::from_u64(1); let __ret: [G; OUT_233] = [__v_34, __v_31]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -22124,7 +22358,7 @@ fn aiur_fn_233( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __ret: [G; OUT_233] = [__v_36, __v_37]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -22134,14 +22368,14 @@ fn aiur_fn_233( 1u64 => { let __v_38: G = G::from_u64(1); let __ret: [G; OUT_233] = [__v_38, __v_31]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); let __ret: [G; OUT_233] = [__v_38, __v_39]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22156,7 +22390,7 @@ fn aiur_fn_233( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __ret: [G; OUT_233] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22165,7 +22399,7 @@ fn aiur_fn_233( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __ret: [G; OUT_233] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22182,6 +22416,7 @@ fn aiur_fn_234( unconstrained: bool, ) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(64); @@ -22189,7 +22424,7 @@ fn aiur_fn_234( match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_234] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[234].weight(); } record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -22197,11 +22432,11 @@ fn aiur_fn_234( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[234].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_234] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[234].weight(); } record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22218,21 +22453,22 @@ fn aiur_fn_235( unconstrained: bool, ) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[234].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[234].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[234].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_235] = [__v_2, __v_5, __v_8, __v_9]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[235].weight(); } record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -22247,9 +22483,10 @@ fn aiur_fn_236( unconstrained: bool, ) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0]; let __cu = true; let __hit = record.function_queries[235].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -22303,9 +22540,9 @@ fn aiur_fn_236( match __v_36.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); - let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_236] = [__v_38]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[236].weight(); } record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -22319,10 +22556,10 @@ fn aiur_fn_236( let __v_42: G = (__v_9 + __v_41); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_236] = [__v_46]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[236].weight(); } record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -22339,11 +22576,11 @@ fn aiur_fn_236( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); - let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_236] = [__v_52]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[236].weight(); } record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -22359,12 +22596,12 @@ fn aiur_fn_236( let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_236] = [__v_56]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[236].weight(); } record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22385,202 +22622,203 @@ fn aiur_fn_237( unconstrained: bool, ) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[144].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_3]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; let __hit = record.function_queries[145].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[145].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_5]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_7]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; let __hit = record.function_queries[159].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[159].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[159].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_9]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; let __hit = record.function_queries[160].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_11]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_13]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_15]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_17]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_19]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_21]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_23]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[165].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_25]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[166].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_27]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_29]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[168].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_31]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; match __v_32.as_canonical_u64() { 1u64 => { let __v_33: G = G::from_u64(1); let __ret: [G; OUT_237] = [__v_33]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); let __ret: [G; OUT_237] = [__v_33]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22627,46 +22865,47 @@ fn aiur_fn_238( unconstrained: bool, ) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[151].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; let __hit = record.function_queries[157].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_18 + __v_20); let __v_22: G = (__v_16 + __v_21); @@ -22678,7 +22917,7 @@ fn aiur_fn_238( let __v_28: G = (__v_4 + __v_27); let __v_29: G = (__v_2 + __v_28); let __ret: [G; OUT_238] = [__v_29]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -22693,8 +22932,9 @@ fn aiur_fn_239( unconstrained: bool, ) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -22705,61 +22945,61 @@ fn aiur_fn_239( 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_239] = [__v_5, __v_3]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[239].weight(); } record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_239] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[239].weight(); } record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[143].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_239] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[239].weight(); } record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_239] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[239].weight(); } record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[240].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_239] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[239].weight(); } record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_239] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[239].weight(); } record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22776,40 +23016,41 @@ fn aiur_fn_240( unconstrained: bool, ) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[144].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_240] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_240] = [__v_10, __v_13]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22818,9 +23059,9 @@ fn aiur_fn_240( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_240] = [__v_8, __v_11]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22829,9 +23070,9 @@ fn aiur_fn_240( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_240] = [__v_6, __v_9]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22848,13 +23089,14 @@ fn aiur_fn_241( unconstrained: bool, ) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(7); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_241] = [__v_4]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[241].weight(); } record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -22869,55 +23111,56 @@ fn aiur_fn_242( unconstrained: bool, ) -> Result<[G; OUT_242], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_242] = [__v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[147].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_242] = [__v_15, __v_16, __v_18]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -22925,9 +23168,9 @@ fn aiur_fn_242( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); - let __v_19: G = { let __values: [G; 10] = [__v_17, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 10] = [__v_17, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_242] = [__v_15, __v_16, __v_19]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22939,9 +23182,9 @@ fn aiur_fn_242( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 10] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_242] = [__v_11, __v_12, __v_15]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22951,9 +23194,9 @@ fn aiur_fn_242( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_242] = [__v_9, __v_10, __v_13]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22963,9 +23206,9 @@ fn aiur_fn_242( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_242] = [__v_5, __v_6, __v_9]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -22982,23 +23225,24 @@ fn aiur_fn_243( unconstrained: bool, ) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); let __v_6: G = (__v_0 * __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[147].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, @@ -23010,9 +23254,9 @@ fn aiur_fn_243( break '__mc_1 [__v_2]; }, _ => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; break '__mc_1 [__v_9]; }, @@ -23023,15 +23267,15 @@ fn aiur_fn_243( let __v_10: G = G::from_u64(2); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_10, __v_7, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __v_15: G = { let __values: [G; 4] = [__v_10, __v_7, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_9, __v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_9, __v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_243] = [__v_18]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[243].weight(); } record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -23046,6 +23290,7 @@ fn aiur_fn_244( unconstrained: bool, ) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -23053,34 +23298,34 @@ fn aiur_fn_244( let __v_4: G = (__v_0 - __v_2); match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[114].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_244] = [__v_6]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[244].weight(); } record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_244] = [__v_7]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[244].weight(); } record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_244] = [__v_7]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[244].weight(); } record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -23099,44 +23344,45 @@ fn aiur_fn_245( unconstrained: bool, ) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_245] = [__v_4]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[245].weight(); } record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_245] = [__v_11]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[245].weight(); } record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_245] = [__v_10]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[245].weight(); } record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -23155,37 +23401,38 @@ fn aiur_fn_246( unconstrained: bool, ) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_246] = [__v_9]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[246].weight(); } record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_7 - __v_8); let __v_10: G = (__v_0 * __v_9); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -23201,14 +23448,14 @@ fn aiur_fn_246( let __v_15: G = (__v_2 - __v_14); let __v_16: G = (__v_0 + __v_15); let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); let __v_20: G = (__v_16 * __v_19); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_20, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_20, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_246] = [__v_21]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[246].weight(); } record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -23225,30 +23472,31 @@ fn aiur_fn_247( unconstrained: bool, ) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_247] = [__v_4]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[247].weight(); } record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, @@ -23269,31 +23517,31 @@ fn aiur_fn_247( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 10] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_23, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_23, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_24, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(1); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_247] = [__v_28]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[247].weight(); } record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_26, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __ret: [G; OUT_247] = [__v_27]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[247].weight(); } record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -23312,34 +23560,35 @@ fn aiur_fn_248( unconstrained: bool, ) -> Result<[G; OUT_248], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_248] = [__v_8]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[248].weight(); } record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, @@ -23349,16 +23598,16 @@ fn aiur_fn_248( } }; let __v_9: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_11 - __v_12); let __v_14: G = (__v_0 * __v_13); let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; break '__mc_1 [__v_15]; }, @@ -23369,7 +23618,7 @@ fn aiur_fn_248( }; let __v_15: G = __mc_out___mc_1[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_16 - __v_17); let __v_19: G = (__v_0 * __v_18); @@ -23384,20 +23633,20 @@ fn aiur_fn_248( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_33, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_34, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_34, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; match __v_35.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_19, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __ret: [G; OUT_248] = [__v_36]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[248].weight(); } record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -23413,12 +23662,12 @@ fn aiur_fn_248( let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(1); let __v_47: G = G::from_u64(1); - let __v_48: G = { let __values: [G; 10] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_49: G = { let __values: [G; 10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_48]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __v_48: G = { let __values: [G; 10] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_49: G = { let __values: [G; 10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_48]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_248] = [__v_50]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[248].weight(); } record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -23437,20 +23686,21 @@ fn aiur_fn_249( unconstrained: bool, ) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[151].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_6 + __v_8); match __v_9.as_canonical_u64() { @@ -23463,28 +23713,28 @@ fn aiur_fn_249( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_249] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[249].weight(); } record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[242].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; break '__mc_0 [__v_19]; }, @@ -23492,11 +23742,11 @@ fn aiur_fn_249( let __v_19: G = G::from_u64(1); let __v_20: G = (__v_19 - __v_15); let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_21 - __v_22); let __v_24: G = (__v_20 * __v_23); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_24, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_24, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_0 [__v_25]; }, @@ -23505,12 +23755,12 @@ fn aiur_fn_249( let __v_19: G = __mc_out___mc_0[0]; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_249] = [__v_20, __v_23]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[249].weight(); } record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -23518,9 +23768,9 @@ fn aiur_fn_249( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_249] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[249].weight(); } record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -23536,26 +23786,26 @@ fn aiur_fn_249( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_249] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[249].weight(); } record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[242].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[250].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_249] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[249].weight(); } record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -23563,9 +23813,9 @@ fn aiur_fn_249( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_249] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[249].weight(); } record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -23586,52 +23836,53 @@ fn aiur_fn_250( unconstrained: bool, ) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; let __hit = record.function_queries[157].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = (__v_5 + __v_10); match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[247].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; break '__mc_0 [__v_18]; }, _ => { - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; break '__mc_0 [__v_20]; }, @@ -23647,18 +23898,18 @@ fn aiur_fn_250( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_33: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_15, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_15, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_33 - __v_35); let __v_37: G = (__v_2 * __v_36); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; break '__mc_0 [__v_39]; }, @@ -23669,12 +23920,12 @@ fn aiur_fn_250( let __v_18: G = __mc_out___mc_0[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_250] = [__v_19, __v_22]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -23682,55 +23933,55 @@ fn aiur_fn_250( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_250] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[242].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => aiur_fn_242(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; break '__mc_1 [__v_19]; }, _ => { - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); let __v_22: G = (__v_21 - __v_15); let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_23 - __v_24); let __v_26: G = (__v_22 * __v_25); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; break '__mc_1 [__v_27]; }, _ => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { @@ -23740,34 +23991,34 @@ fn aiur_fn_250( let __v_26: G = (__v_15 - __v_25); let __v_27: G = (__v_2 + __v_26); let __v_28: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_28 - __v_29); let __v_31: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = (__v_31 - __v_32); let __v_34: G = (__v_30 * __v_33); let __v_35: G = (__v_27 * __v_34); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_35, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; break '__mc_1 [__v_37]; }, _ => { - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, _ => { - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, @@ -23782,12 +24033,12 @@ fn aiur_fn_250( let __v_19: G = __mc_out___mc_1[0]; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_250] = [__v_20, __v_23]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -23795,9 +24046,9 @@ fn aiur_fn_250( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_250] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -23816,26 +24067,27 @@ fn aiur_fn_251( unconstrained: bool, ) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_251] = [__v_0]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[251].weight(); } record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_7, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_251] = [__v_8]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[251].weight(); } record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -23855,254 +24107,255 @@ fn aiur_fn_252( unconstrained: bool, ) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[114].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; let __hit = record.function_queries[159].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[159].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[159].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; let __hit = record.function_queries[160].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_11, __v_14]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_13, __v_16]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_15, __v_18]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_17, __v_20]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[165].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[138].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_19, __v_22]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[166].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[139].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[139].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_21, __v_24]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[140].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_23, __v_26]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[168].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[141].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_25, __v_28]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[142].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_27, __v_30]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[334].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_29, __v_31]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_32]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __ret: [G; OUT_252] = [__v_31, __v_33]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -24110,9 +24363,9 @@ fn aiur_fn_252( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_252] = [__v_31, __v_35]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24155,43 +24408,44 @@ fn aiur_fn_253( unconstrained: bool, ) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_253] = [__v_8, __v_0, __v_11]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(2); let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -24202,16 +24456,16 @@ fn aiur_fn_253( 0u64 => { let __v_19: G = G::from_u64(1); let __ret: [G; OUT_253] = [__v_19, __v_12, __v_17]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_253] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24220,9 +24474,9 @@ fn aiur_fn_253( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_253] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24231,9 +24485,9 @@ fn aiur_fn_253( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_253] = [__v_11, __v_0, __v_14]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24244,9 +24498,9 @@ fn aiur_fn_253( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_253] = [__v_6, __v_0, __v_9]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24263,6 +24517,7 @@ fn aiur_fn_254( unconstrained: bool, ) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); @@ -24276,55 +24531,55 @@ fn aiur_fn_254( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[144].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(3); let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_254] = [__v_27]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[254].weight(); } record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 4] = [__v_25, __v_26, __v_29, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 4] = [__v_25, __v_26, __v_29, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_32: G = G::from_u64(7); let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_36: G = G::from_u64(3); let __v_37: G = G::from_u64(3); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 4] = [__v_37, __v_31, __v_0, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 4] = [__v_37, __v_31, __v_0, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 4] = [__v_36, __v_39, __v_35, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 4] = [__v_36, __v_39, __v_35, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_42: G = G::from_u64(3); let __v_43: G = G::from_u64(0); - let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_254] = [__v_44]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[254].weight(); } record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24341,8 +24596,9 @@ fn aiur_fn_255( unconstrained: bool, ) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -24350,55 +24606,55 @@ fn aiur_fn_255( match __v_1.as_canonical_u64() { 7u64 => { let __ret: [G; OUT_255] = [__v_0]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[255].weight(); } record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_255] = [__v_0]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[255].weight(); } record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_12, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[254].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[254].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => aiur_fn_254(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_255] = [__v_16]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[255].weight(); } record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_255] = [__v_0]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[255].weight(); } record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_255] = [__v_0]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[255].weight(); } record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24417,42 +24673,43 @@ fn aiur_fn_256( unconstrained: bool, ) -> Result<[G; OUT_256], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_256] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[256].weight(); } record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_4, __v_5, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_4, __v_5, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_17, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_256] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[256].weight(); } record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24469,53 +24726,54 @@ fn aiur_fn_257( unconstrained: bool, ) -> Result<[G; OUT_257], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[144].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_257] = [__v_17]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[257].weight(); } record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_10, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; @@ -24524,13 +24782,13 @@ fn aiur_fn_257( 0u64 => { let __v_26: G = G::from_bool((__v_23 == G::ZERO)); let __ret: [G; OUT_257] = [__v_26]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[257].weight(); } record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __ret: [G; OUT_257] = [__v_26]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[257].weight(); } record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24538,7 +24796,7 @@ fn aiur_fn_257( _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_257] = [__v_20]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[257].weight(); } record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24548,7 +24806,7 @@ fn aiur_fn_257( _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_257] = [__v_15]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[257].weight(); } record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24556,7 +24814,7 @@ fn aiur_fn_257( _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_257] = [__v_9]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[257].weight(); } record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24564,7 +24822,7 @@ fn aiur_fn_257( _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_257] = [__v_5]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[257].weight(); } record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24581,6 +24839,7 @@ fn aiur_fn_258( unconstrained: bool, ) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -24594,15 +24853,15 @@ fn aiur_fn_258( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_258] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -24611,18 +24870,18 @@ fn aiur_fn_258( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_258] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_10: G = (__v_1 + __v_2); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_10 + __v_11); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[257].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[257].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => aiur_fn_257(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { @@ -24630,40 +24889,40 @@ fn aiur_fn_258( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_258] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_4 + __v_16); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_20, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_20, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[114].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_23, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_258] = [__v_21, __v_24]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[256].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_258] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24689,18 +24948,19 @@ fn aiur_fn_259( unconstrained: bool, ) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; let __hit = record.function_queries[145].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[145].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[144].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { @@ -24712,32 +24972,32 @@ fn aiur_fn_259( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_259] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_259] = [__v_16, __v_19]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -24745,9 +25005,9 @@ fn aiur_fn_259( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_259] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24765,34 +25025,34 @@ fn aiur_fn_259( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_259] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_259] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -24800,9 +25060,9 @@ fn aiur_fn_259( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_259] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24810,11 +25070,11 @@ fn aiur_fn_259( } }, _ => { - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[260].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_259] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24833,6 +25093,7 @@ fn aiur_fn_260( unconstrained: bool, ) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -24844,41 +25105,41 @@ fn aiur_fn_260( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_260] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_14, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_260] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -24886,9 +25147,9 @@ fn aiur_fn_260( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_260] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24898,24 +25159,24 @@ fn aiur_fn_260( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_260] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[261].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[261].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[261].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_261] = unsafe { *(record.function_queries[261].output_at(__i).as_ptr() as *const [G; OUT_261]) }; __ret }, _ => aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_260] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -24923,9 +25184,9 @@ fn aiur_fn_260( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_260] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -24946,33 +25207,34 @@ fn aiur_fn_261( unconstrained: bool, ) -> Result<[G; OUT_261], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_11 - __v_12); let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_14 - __v_17); let __v_19: G = (__v_13 * __v_18); @@ -24984,25 +25246,25 @@ fn aiur_fn_261( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_261] = [__v_22, __v_26]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[261].weight(); } record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[256].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; match __v_24.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(2); let __ret: [G; OUT_261] = [__v_26, __v_25]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[261].weight(); } record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -25010,19 +25272,19 @@ fn aiur_fn_261( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_261] = [__v_26, __v_30]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[261].weight(); } record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[262].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[262].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[262].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_262] = unsafe { *(record.function_queries[262].output_at(__i).as_ptr() as *const [G; OUT_262]) }; __ret }, _ => aiur_fn_262(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_261] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[261].weight(); } record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -25041,6 +25303,7 @@ fn aiur_fn_262( unconstrained: bool, ) -> Result<[G; OUT_262], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -25048,21 +25311,21 @@ fn aiur_fn_262( let __v_4: G = G::from_u64(2); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_4, __v_0, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_0, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_262] = [__v_17]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[262].weight(); } record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -25077,6 +25340,7 @@ fn aiur_fn_263( unconstrained: bool, ) -> Result<[G; OUT_263], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -25090,25 +25354,25 @@ fn aiur_fn_263( match __v_9.as_canonical_u64() { 8u64 => { let __ret: [G; OUT_263] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[263].weight(); } record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_263] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[263].weight(); } record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[263].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[263].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[263].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25118,12 +25382,12 @@ fn aiur_fn_263( let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[263].weight(); } record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[263].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[263].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[263].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25133,12 +25397,12 @@ fn aiur_fn_263( let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[263].weight(); } record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_13: G = G::from_u64(3); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[263].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[263].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[263].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25148,12 +25412,12 @@ fn aiur_fn_263( let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[263].weight(); } record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_13: G = G::from_u64(4); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[263].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[263].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[263].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25163,12 +25427,12 @@ fn aiur_fn_263( let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[263].weight(); } record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_13: G = G::from_u64(5); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[263].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[263].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[263].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25178,12 +25442,12 @@ fn aiur_fn_263( let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[263].weight(); } record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __v_13: G = G::from_u64(6); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[263].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[263].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[263].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25193,12 +25457,12 @@ fn aiur_fn_263( let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[263].weight(); } record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __v_13: G = G::from_u64(7); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[263].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[263].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[263].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25208,12 +25472,12 @@ fn aiur_fn_263( let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[263].weight(); } record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(8); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[263].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[263].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[263].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25223,7 +25487,7 @@ fn aiur_fn_263( let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[263].weight(); } record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -25247,16 +25511,17 @@ fn aiur_fn_264( unconstrained: bool, ) -> Result<[G; OUT_264], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_264] = [__v_0]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -25264,18 +25529,18 @@ fn aiur_fn_264( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_264] = [__v_7]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[264].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_264] = unsafe { *(record.function_queries[264].output_at(__i).as_ptr() as *const [G; OUT_264]) }; __ret }, _ => aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_264] = [__v_7]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -25297,6 +25562,7 @@ fn aiur_fn_265( unconstrained: bool, ) -> Result<[G; OUT_265], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(0); @@ -25307,7 +25573,7 @@ fn aiur_fn_265( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[263].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[263].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[263].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -25317,9 +25583,9 @@ fn aiur_fn_265( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = G::from_u64(8); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[264].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_264] = unsafe { *(record.function_queries[264].output_at(__i).as_ptr() as *const [G; OUT_264]) }; __ret }, _ => aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -25327,18 +25593,18 @@ fn aiur_fn_265( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[265].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[265].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[265].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_265] = unsafe { *(record.function_queries[265].output_at(__i).as_ptr() as *const [G; OUT_265]) }; __ret }, _ => aiur_fn_265(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, } }; let __v_23: G = __mc_out___mc_0[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; @@ -25351,25 +25617,25 @@ fn aiur_fn_265( let __v_33: G = __loaded[9]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; match __v_34.as_canonical_u64() { 1u64 => { let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(1); - let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_265] = [__v_37]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[265].weight(); } record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_265] = [__v_39]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[265].weight(); } record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -25379,9 +25645,9 @@ fn aiur_fn_265( }, _ => { let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_265] = [__v_35]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[265].weight(); } record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -25398,8 +25664,9 @@ fn aiur_fn_266( unconstrained: bool, ) -> Result<[G; OUT_266], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -25413,51 +25680,51 @@ fn aiur_fn_266( 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_266] = [__v_12]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[266].weight(); } record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[266].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[266].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[266].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_266] = [__v_13]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[266].weight(); } record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[266].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[266].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[266].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[266].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[266].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[266].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_266] = [__v_13]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[266].weight(); } record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[266].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[266].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[266].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[266].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[266].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[266].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_266] = [__v_13]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[266].weight(); } record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(4); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_266] = [__v_13]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[266].weight(); } record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -25477,9 +25744,10 @@ fn aiur_fn_267( unconstrained: bool, ) -> Result<[G; OUT_267], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -25494,24 +25762,24 @@ fn aiur_fn_267( 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_267] = [__v_14]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[267].weight(); } record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[266].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[266].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[266].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[267].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_267] = [__v_17]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[267].weight(); } record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -25531,12 +25799,13 @@ fn aiur_fn_268( unconstrained: bool, ) -> Result<[G; OUT_268], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -25557,169 +25826,169 @@ fn aiur_fn_268( let __v_22: G = __loaded[17]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[266].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[266].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[266].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_268] = [__v_28]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_268] = [__v_26]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_14, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[267].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_268] = [__v_28]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_14, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[267].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_268] = [__v_28]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(8); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_268] = [__v_28]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[280].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[280].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[280].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_268] = [__v_29]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[280].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[280].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[280].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[265].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[265].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[265].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_265] = unsafe { *(record.function_queries[265].output_at(__i).as_ptr() as *const [G; OUT_265]) }; __ret }, _ => aiur_fn_265(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(7); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_268] = [__v_30]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __v_23: G = G::from_u64(3); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_268] = [__v_27]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_268] = [__v_27]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 9u64 => { let __v_23: G = G::from_u64(5); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_268] = [__v_27]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 10u64 => { let __v_23: G = G::from_u64(6); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_268] = [__v_27]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 11u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_268] = [__v_28]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -25744,6 +26013,7 @@ fn aiur_fn_269( unconstrained: bool, ) -> Result<[G; OUT_269], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -25763,18 +26033,18 @@ fn aiur_fn_269( let __v_16: G = inp[16]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(0); let __ret: [G; OUT_269] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { @@ -25793,14 +26063,14 @@ fn aiur_fn_269( let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); let __ret: [G; OUT_269] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_20: G = G::from_u64(2); let __v_21: G = G::from_u64(0); let __ret: [G; OUT_269] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -25822,6 +26092,7 @@ fn aiur_fn_270( unconstrained: bool, ) -> Result<[G; OUT_270], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -25838,14 +26109,14 @@ fn aiur_fn_270( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __ret: [G; OUT_270] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[270].weight(); } record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -25862,6 +26133,7 @@ fn aiur_fn_271( unconstrained: bool, ) -> Result<[G; OUT_271], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -25878,14 +26150,14 @@ fn aiur_fn_271( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __ret: [G; OUT_271] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[271].weight(); } record.function_queries[271].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -25902,8 +26174,9 @@ fn aiur_fn_272( unconstrained: bool, ) -> Result<[G; OUT_272], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -25944,16 +26217,16 @@ fn aiur_fn_272( 1u64 => { let __v_37: G = G::from_u64(0); let __ret: [G; OUT_272] = [__v_37]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[272].weight(); } record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[272].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_37 + __v_38); let __ret: [G; OUT_272] = [__v_39]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[272].weight(); } record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -25973,9 +26246,10 @@ fn aiur_fn_273( unconstrained: bool, ) -> Result<[G; OUT_273], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -26017,13 +26291,13 @@ fn aiur_fn_273( match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_273] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[273].weight(); } record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_37, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[273].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[273].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[273].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; @@ -26059,7 +26333,7 @@ fn aiur_fn_273( let __v_72: G = __r_arr[32]; let __v_73: G = __r_arr[33]; let __ret: [G; OUT_273] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; - if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[273].weight(); } record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -26081,6 +26355,7 @@ fn aiur_fn_274( unconstrained: bool, ) -> Result<[G; OUT_274], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -26116,20 +26391,20 @@ fn aiur_fn_274( let __v_32: G = inp[32]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(5); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[272].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); let __ret: [G; OUT_274] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; - if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[274].weight(); } record.function_queries[274].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -26146,6 +26421,7 @@ fn aiur_fn_275( unconstrained: bool, ) -> Result<[G; OUT_275], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -26188,20 +26464,20 @@ fn aiur_fn_275( let __v_39: G = inp[39]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(6); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); let __ret: [G; OUT_275] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[275].weight(); } record.function_queries[275].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -26218,13 +26494,14 @@ fn aiur_fn_276( unconstrained: bool, ) -> Result<[G; OUT_276], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -26240,26 +26517,26 @@ fn aiur_fn_276( 1u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); - let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_276] = [__v_19]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[276].weight(); } record.function_queries[276].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[276].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[276].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[276].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_276] = [__v_23]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[276].weight(); } record.function_queries[276].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -26281,6 +26558,7 @@ fn aiur_fn_277( unconstrained: bool, ) -> Result<[G; OUT_277], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -26333,24 +26611,24 @@ fn aiur_fn_277( let __v_49: G = inp[49]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[276].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[276].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[276].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(7); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __ret: [G; OUT_277] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[277].weight(); } record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -26367,8 +26645,9 @@ fn aiur_fn_278( unconstrained: bool, ) -> Result<[G; OUT_278], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26406,10 +26685,10 @@ fn aiur_fn_278( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(2); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_20(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[20].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[20].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[20].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_20] = unsafe { *(record.function_queries[20].output_at(__i).as_ptr() as *const [G; OUT_20]) }; __ret }, _ => aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -26459,7 +26738,7 @@ fn aiur_fn_278( let __v_84: G = __r_arr[46]; let __v_85: G = __r_arr[47]; let __v_86: G = __r_arr[48]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_87: G = __loaded[0]; let __v_88: G = __loaded[1]; let __v_89: G = __loaded[2]; @@ -26475,7 +26754,7 @@ fn aiur_fn_278( return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) }); } let __ret: [G; OUT_278] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; - if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[278].weight(); } record.function_queries[278].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -26490,8 +26769,9 @@ fn aiur_fn_279( unconstrained: bool, ) -> Result<[G; OUT_279], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26529,16 +26809,16 @@ fn aiur_fn_279( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(3); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_38: G = __loaded[0]; let __v_39: G = __loaded[1]; let __v_40: G = __loaded[2]; match __v_38.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_279] = [__v_39]; - if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[279].weight(); } record.function_queries[279].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -26558,8 +26838,9 @@ fn aiur_fn_280( unconstrained: bool, ) -> Result<[G; OUT_280], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26597,11 +26878,11 @@ fn aiur_fn_280( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(4); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_20(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[20].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[20].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[20].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_20] = unsafe { *(record.function_queries[20].output_at(__i).as_ptr() as *const [G; OUT_20]) }; __ret }, _ => aiur_fn_20(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_280] = [__v_37]; - if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[280].weight(); } record.function_queries[280].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -26616,13 +26897,14 @@ fn aiur_fn_281( unconstrained: bool, ) -> Result<[G; OUT_281], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 2u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_281] = [__v_2]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[281].weight(); } record.function_queries[281].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { @@ -26630,13 +26912,13 @@ fn aiur_fn_281( 0u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_281] = [__v_2]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[281].weight(); } record.function_queries[281].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_281] = [__v_2]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[281].weight(); } record.function_queries[281].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -26646,13 +26928,13 @@ fn aiur_fn_281( 1u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_281] = [__v_2]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[281].weight(); } record.function_queries[281].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_281] = [__v_2]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[281].weight(); } record.function_queries[281].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -26674,6 +26956,7 @@ fn aiur_fn_282( unconstrained: bool, ) -> Result<[G; OUT_282], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -26690,22 +26973,22 @@ fn aiur_fn_282( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[281].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[281].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[281].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_282] = [__v_17]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[282].weight(); } record.function_queries[282].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[291].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[291].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_282] = [__v_15]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[282].weight(); } record.function_queries[282].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -26724,8 +27007,9 @@ fn aiur_fn_283( unconstrained: bool, ) -> Result<[G; OUT_283], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -26778,25 +27062,25 @@ fn aiur_fn_283( _ => { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = true; let __hit = record.function_queries[279].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[281].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[281].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[281].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; match __v_50.as_canonical_u64() { 0u64 => { let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); - let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_0 [__v_53]; }, _ => { let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); - let __v_54: G = { let __values: [G; 3] = [__v_52, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_55: G = { let __values: [G; 3] = [__v_51, __v_0, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_52, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_51, __v_0, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_0 [__v_55]; }, } @@ -26804,7 +27088,7 @@ fn aiur_fn_283( } }; let __v_50: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[269].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -26817,16 +27101,16 @@ fn aiur_fn_283( let __v_60: G = __r_arr[9]; let __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; - let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_283] = [__v_63]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[283].weight(); } record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[270].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -26839,16 +27123,16 @@ fn aiur_fn_283( let __v_61: G = __r_arr[9]; let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; - let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_283] = [__v_64]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[283].weight(); } record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[271].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[271].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[271].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -26861,18 +27145,18 @@ fn aiur_fn_283( let __v_61: G = __r_arr[9]; let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; - let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_283] = [__v_64]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[283].weight(); } record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[284].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_284] = unsafe { *(record.function_queries[284].output_at(__i).as_ptr() as *const [G; OUT_284]) }; __ret }, _ => aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __ret: [G; OUT_283] = [__v_49]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[283].weight(); } record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -26880,12 +27164,12 @@ fn aiur_fn_283( 6u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_10, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[285].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_283] = [__v_50]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[283].weight(); } record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -26893,14 +27177,14 @@ fn aiur_fn_283( 4u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_283] = [__v_51]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[283].weight(); } record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -26908,12 +27192,12 @@ fn aiur_fn_283( 5u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_283] = [__v_50]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[283].weight(); } record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -26922,10 +27206,10 @@ fn aiur_fn_283( let __v_49: G = G::from_u64(0); let __v_50: G = G::from_u64(1); let __v_51: G = G::from_u64(1); - let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[277].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -26938,9 +27222,9 @@ fn aiur_fn_283( let __v_64: G = __r_arr[9]; let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; - let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_283] = [__v_67]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[283].weight(); } record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -26962,6 +27246,7 @@ fn aiur_fn_284( unconstrained: bool, ) -> Result<[G; OUT_284], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -26972,7 +27257,7 @@ fn aiur_fn_284( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -27025,7 +27310,7 @@ fn aiur_fn_284( _ => { match __v_10.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[764].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -27073,11 +27358,11 @@ fn aiur_fn_284( let __v_102: G = __r_arr[44]; match __v_58.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = true; let __hit = record.function_queries[279].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[282].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; let __hit = record.function_queries[269].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; @@ -27090,9 +27375,9 @@ fn aiur_fn_284( let __v_114: G = __r_arr[9]; let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; - let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_284] = [__v_117]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[284].weight(); } record.function_queries[284].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -27119,9 +27404,10 @@ fn aiur_fn_285( unconstrained: bool, ) -> Result<[G; OUT_285], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -27174,7 +27460,7 @@ fn aiur_fn_285( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[288].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[288].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[288].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -27222,9 +27508,9 @@ fn aiur_fn_285( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[291].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[291].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[274].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[274].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27237,9 +27523,9 @@ fn aiur_fn_285( let __v_105: G = __r_arr[9]; let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; - let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_285] = [__v_108]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[285].weight(); } record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -27266,10 +27552,11 @@ fn aiur_fn_286( unconstrained: bool, ) -> Result<[G; OUT_286], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -27322,7 +27609,7 @@ fn aiur_fn_286( _ => { match __v_3.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[288].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[288].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[288].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -27372,7 +27659,7 @@ fn aiur_fn_286( 1u64 => { match __v_52.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_78, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[273].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[273].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[273].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27407,9 +27694,9 @@ fn aiur_fn_286( let __v_127: G = __r_arr[31]; let __v_128: G = __r_arr[32]; let __v_129: G = __r_arr[33]; - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_4, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[291].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[291].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_130: G = __r_arr[0]; - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[275].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[275].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => aiur_fn_275(__args, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = __r_arr[1]; let __v_133: G = __r_arr[2]; @@ -27422,9 +27709,9 @@ fn aiur_fn_286( let __v_140: G = __r_arr[9]; let __v_141: G = __r_arr[10]; let __v_142: G = __r_arr[11]; - let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_286] = [__v_143]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[286].weight(); } record.function_queries[286].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -27453,9 +27740,10 @@ fn aiur_fn_287( unconstrained: bool, ) -> Result<[G; OUT_287], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -27508,7 +27796,7 @@ fn aiur_fn_287( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[288].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[288].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[288].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -27556,9 +27844,9 @@ fn aiur_fn_287( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[291].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[291].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[277].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27571,9 +27859,9 @@ fn aiur_fn_287( let __v_105: G = __r_arr[9]; let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; - let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_287] = [__v_108]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[287].weight(); } record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -27600,9 +27888,10 @@ fn aiur_fn_288( unconstrained: bool, ) -> Result<[G; OUT_288], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -27655,13 +27944,13 @@ fn aiur_fn_288( match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_288] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[288].weight(); } record.function_queries[288].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 - __v_49); - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_48, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[288].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[288].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[288].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -27708,7 +27997,7 @@ fn aiur_fn_288( let __v_94: G = __r_arr[43]; let __v_95: G = __r_arr[44]; let __ret: [G; OUT_288] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[288].weight(); } record.function_queries[288].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -27730,6 +28019,7 @@ fn aiur_fn_289( unconstrained: bool, ) -> Result<[G; OUT_289], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_1: G = G::from_u8(__gb[0]); @@ -27744,13 +28034,13 @@ fn aiur_fn_289( if !unconstrained { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; if !unconstrained { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; if !unconstrained { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; if (__v_9 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection index bytes do not recompose to the index".to_string()) }); } let __ret: [G; OUT_289] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[289].weight(); } record.function_queries[289].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -27765,10 +28055,11 @@ fn aiur_fn_290( unconstrained: bool, ) -> Result<[G; OUT_290], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[288].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[288].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[288].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -27814,7 +28105,7 @@ fn aiur_fn_290( let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[289].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -27891,22 +28182,22 @@ fn aiur_fn_290( let __v_100: G = __mc_out___mc_0[44]; let __v_101: G = G::from_u64(1); let __v_102: G = G::from_u64(1); - let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_104: G = G::from_u64(1); let __v_105: G = G::from_u64(1); - let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_107: G = G::from_u64(1); let __v_108: G = G::from_u64(1); - let __v_109: G = { let __values: [G; 3] = [__v_107, __v_108, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_109: G = { let __values: [G; 3] = [__v_107, __v_108, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_110: G = G::from_u64(1); let __v_111: G = G::from_u64(1); - let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; let __hit = record.function_queries[71].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[71].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_71] = unsafe { *(record.function_queries[71].output_at(__i).as_ptr() as *const [G; OUT_71]) }; __ret }, _ => aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_113]; let __cu = unconstrained; let __hit = record.function_queries[21].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[21].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_21] = unsafe { *(record.function_queries[21].output_at(__i).as_ptr() as *const [G; OUT_21]) }; __ret }, _ => aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; let __ret: [G; OUT_290] = [__v_114]; - if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[290].weight(); } record.function_queries[290].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -27921,13 +28212,14 @@ fn aiur_fn_291( unconstrained: bool, ) -> Result<[G; OUT_291], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[292].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_291] = [__v_3]; - if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[291].weight(); } record.function_queries[291].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -27942,11 +28234,12 @@ fn aiur_fn_292( unconstrained: bool, ) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -27998,22 +28291,22 @@ fn aiur_fn_292( 1u64 => { let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); - let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_292] = [__v_53]; - if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[292].weight(); } record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[290].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_3 + __v_53); - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[292].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_292] = [__v_56]; - if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[292].weight(); } record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28033,8 +28326,9 @@ fn aiur_fn_293( unconstrained: bool, ) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -28042,25 +28336,25 @@ fn aiur_fn_293( 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_293] = [__v_4]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[293].weight(); } record.function_queries[293].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_293] = [__v_4]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[293].weight(); } record.function_queries[293].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_293] = [__v_4]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[293].weight(); } record.function_queries[293].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[293].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[293].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { @@ -28068,13 +28362,13 @@ fn aiur_fn_293( 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_293] = [__v_6]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[293].weight(); } record.function_queries[293].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_293] = [__v_6]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[293].weight(); } record.function_queries[293].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -28082,16 +28376,16 @@ fn aiur_fn_293( _ => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_293] = [__v_6]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[293].weight(); } record.function_queries[293].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[293].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_293] = [__v_4]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[293].weight(); } record.function_queries[293].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28111,15 +28405,16 @@ fn aiur_fn_294( unconstrained: bool, ) -> Result<[G; OUT_294], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -28127,88 +28422,88 @@ fn aiur_fn_294( 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 2u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); let __ret: [G; OUT_294] = [__v_10]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); let __ret: [G; OUT_294] = [__v_10]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 4u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -28217,13 +28512,13 @@ fn aiur_fn_294( let __v_8: G = (__v_3 - __v_6); let __v_9: G = G::from_bool((__v_8 == G::ZERO)); let __ret: [G; OUT_294] = [__v_9]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -28245,15 +28540,16 @@ fn aiur_fn_295( unconstrained: bool, ) -> Result<[G; OUT_295], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -28261,13 +28557,13 @@ fn aiur_fn_295( 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28276,7 +28572,7 @@ fn aiur_fn_295( } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -28284,7 +28580,7 @@ fn aiur_fn_295( 1u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -28293,7 +28589,7 @@ fn aiur_fn_295( 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_295] = [__v_9]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -28302,14 +28598,14 @@ fn aiur_fn_295( 1u64 => { let __v_10: G = G::from_u64(2); let __ret: [G; OUT_295] = [__v_10]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[295].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_295] = [__v_10]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28344,9 +28640,10 @@ fn aiur_fn_296( unconstrained: bool, ) -> Result<[G; OUT_296], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -28354,11 +28651,11 @@ fn aiur_fn_296( 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_296] = [__v_5]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[296].weight(); } record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -28366,7 +28663,7 @@ fn aiur_fn_296( 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_296] = [__v_8]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[296].weight(); } record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -28375,24 +28672,24 @@ fn aiur_fn_296( 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_296] = [__v_9]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[296].weight(); } record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[296].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[296].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_296] = [__v_10]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[296].weight(); } record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[296].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[296].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_296] = [__v_10]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[296].weight(); } record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28427,15 +28724,16 @@ fn aiur_fn_297( unconstrained: bool, ) -> Result<[G; OUT_297], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -28443,13 +28741,13 @@ fn aiur_fn_297( 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[297].weight(); } record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[297].weight(); } record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28458,7 +28756,7 @@ fn aiur_fn_297( } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -28466,14 +28764,14 @@ fn aiur_fn_297( 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[297].weight(); } record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[297].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[297].weight(); } record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28498,9 +28796,10 @@ fn aiur_fn_298( unconstrained: bool, ) -> Result<[G; OUT_298], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -28510,10 +28809,10 @@ fn aiur_fn_298( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_298] = [__v_5, __v_10]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[298].weight(); } record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -28522,9 +28821,9 @@ fn aiur_fn_298( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_298] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[298].weight(); } record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -28533,17 +28832,17 @@ fn aiur_fn_298( 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_298] = [__v_7, __v_1]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[298].weight(); } record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[298].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_298] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[298].weight(); } record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28573,27 +28872,28 @@ fn aiur_fn_299( unconstrained: bool, ) -> Result<[G; OUT_299], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_299] = [__v_11]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[299].weight(); } record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { @@ -28602,10 +28902,10 @@ fn aiur_fn_299( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_299] = [__v_11]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[299].weight(); } record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -28613,11 +28913,11 @@ fn aiur_fn_299( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[299].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_299] = [__v_12]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[299].weight(); } record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -28625,15 +28925,15 @@ fn aiur_fn_299( match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_299] = [__v_13]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[299].weight(); } record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_299] = [__v_0]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[299].weight(); } record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28670,15 +28970,16 @@ fn aiur_fn_300( unconstrained: bool, ) -> Result<[G; OUT_300], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -28686,13 +28987,13 @@ fn aiur_fn_300( 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_300] = [__v_8]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[300].weight(); } record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_300] = [__v_8]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[300].weight(); } record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28701,7 +29002,7 @@ fn aiur_fn_300( } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -28709,16 +29010,16 @@ fn aiur_fn_300( 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_300] = [__v_8]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[300].weight(); } record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; match __v_8.as_canonical_u64() { _ => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; match __v_10.as_canonical_u64() { @@ -28729,16 +29030,16 @@ fn aiur_fn_300( let __v_13: G = (__v_9 - __v_11); match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[300].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_300] = [__v_14]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[300].weight(); } record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_300] = [__v_14]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[300].weight(); } record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -28746,7 +29047,7 @@ fn aiur_fn_300( _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_300] = [__v_13]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[300].weight(); } record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -28777,8 +29078,9 @@ fn aiur_fn_301( unconstrained: bool, ) -> Result<[G; OUT_301], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -28786,27 +29088,27 @@ fn aiur_fn_301( 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_301] = [__v_4]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[301].weight(); } record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; match __v_4.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[301].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[301].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[301].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_301] = [__v_5]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[301].weight(); } record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_301] = [__v_6]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[301].weight(); } record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28833,36 +29135,37 @@ fn aiur_fn_302( unconstrained: bool, ) -> Result<[G; OUT_302], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_302] = [__v_0]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[302].weight(); } record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_302] = [__v_0]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[302].weight(); } record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; match __v_8.as_canonical_u64() { _ => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; match __v_10.as_canonical_u64() { @@ -28871,21 +29174,21 @@ fn aiur_fn_302( match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[302].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_302] = [__v_15]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[302].weight(); } record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[302].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_302] = [__v_14]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[302].weight(); } record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -28893,18 +29196,18 @@ fn aiur_fn_302( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[302].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_302] = [__v_17]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[302].weight(); } record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[302].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_302] = [__v_15]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[302].weight(); } record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28948,31 +29251,32 @@ fn aiur_fn_303( unconstrained: bool, ) -> Result<[G; OUT_303], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_303] = [__v_0]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[303].weight(); } record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[304].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[304].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_303] = [__v_6]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[303].weight(); } record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_303] = [__v_0]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[303].weight(); } record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -28981,10 +29285,10 @@ fn aiur_fn_303( } }, _ => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[304].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[304].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_303] = [__v_3]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[303].weight(); } record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -29001,10 +29305,11 @@ fn aiur_fn_304( unconstrained: bool, ) -> Result<[G; OUT_304], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -29013,24 +29318,24 @@ fn aiur_fn_304( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_304] = [__v_14]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[304].weight(); } record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[295].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { @@ -29038,15 +29343,15 @@ fn aiur_fn_304( match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_304] = [__v_13]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[304].weight(); } record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_304] = [__v_0]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[304].weight(); } record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -29058,20 +29363,20 @@ fn aiur_fn_304( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_304] = [__v_15]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[304].weight(); } record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[304].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[304].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_304] = [__v_12]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[304].weight(); } record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -29095,11 +29400,12 @@ fn aiur_fn_305( unconstrained: bool, ) -> Result<[G; OUT_305], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -29108,62 +29414,62 @@ fn aiur_fn_305( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_305] = [__v_19]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[305].weight(); } record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[295].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[299].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_305] = [__v_14]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[305].weight(); } record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_305] = [__v_20]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[305].weight(); } record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[305].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_305] = [__v_13]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[305].weight(); } record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -29187,73 +29493,74 @@ fn aiur_fn_306( unconstrained: bool, ) -> Result<[G; OUT_306], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[303].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_306] = [__v_7]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[306].weight(); } record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_306] = [__v_9]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[306].weight(); } record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_306] = [__v_8]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[306].weight(); } record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_306] = [__v_7]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[306].weight(); } record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[298].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[303].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[305].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_306] = [__v_10]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[306].weight(); } record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_306] = [__v_3]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[306].weight(); } record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[305].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_306] = [__v_9]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[306].weight(); } record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -29280,66 +29587,67 @@ fn aiur_fn_307( unconstrained: bool, ) -> Result<[G; OUT_307], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[303].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_307] = [__v_8]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_3 + __v_8); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_307] = [__v_11]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_307] = [__v_9]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_307] = [__v_9]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[298].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[303].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[305].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_307] = [__v_12]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -29348,17 +29656,17 @@ fn aiur_fn_307( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[305].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_307] = [__v_11]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -29383,27 +29691,28 @@ fn aiur_fn_308( unconstrained: bool, ) -> Result<[G; OUT_308], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_308] = [__v_0]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[308].weight(); } record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[309].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[308].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[308].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_308] = [__v_8]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[308].weight(); } record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -29423,43 +29732,44 @@ fn aiur_fn_309( unconstrained: bool, ) -> Result<[G; OUT_309], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_309] = [__v_0]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[309].weight(); } record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_8, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[296].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[296].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[309].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_309] = [__v_12]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[309].weight(); } record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[297].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { @@ -29482,7 +29792,7 @@ fn aiur_fn_309( } }; let __v_13: G = __mc_out___mc_1[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -29492,7 +29802,7 @@ fn aiur_fn_309( break '__mc_2 [__v_17]; }, 0u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[301].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[301].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[301].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 + __v_18); @@ -29524,7 +29834,7 @@ fn aiur_fn_309( break '__mc_3 [__v_7]; }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -29533,7 +29843,7 @@ fn aiur_fn_309( break '__mc_3 [__v_7]; }, 0u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[302].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_3 [__v_17]; }, @@ -29548,11 +29858,11 @@ fn aiur_fn_309( } }; let __v_14: G = __mc_out___mc_3[0]; - let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_15, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[309].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_309] = [__v_16]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[309].weight(); } record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -29578,19 +29888,20 @@ fn aiur_fn_310( unconstrained: bool, ) -> Result<[G; OUT_310], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_310] = [__v_0]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[310].weight(); } record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -29598,21 +29909,21 @@ fn aiur_fn_310( _ => { match __v_5.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[310].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_310] = [__v_10]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[310].weight(); } record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_310] = [__v_0]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[310].weight(); } record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -29622,7 +29933,7 @@ fn aiur_fn_310( }, _ => { let __ret: [G; OUT_310] = [__v_0]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[310].weight(); } record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -29646,19 +29957,20 @@ fn aiur_fn_311( unconstrained: bool, ) -> Result<[G; OUT_311], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[310].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[310].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -29666,13 +29978,13 @@ fn aiur_fn_311( 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_311] = [__v_10]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[311].weight(); } record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_311] = [__v_10]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[311].weight(); } record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -29681,7 +29993,7 @@ fn aiur_fn_311( } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -29689,43 +30001,43 @@ fn aiur_fn_311( 1u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_311] = [__v_10]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[311].weight(); } record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[295].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = (__v_11 - __v_14); match __v_17.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_12, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[300].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[311].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_311] = [__v_19]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[311].weight(); } record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_311] = [__v_19]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[311].weight(); } record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -29736,7 +30048,7 @@ fn aiur_fn_311( _ => { let __v_18: G = G::from_u64(0); let __ret: [G; OUT_311] = [__v_18]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[311].weight(); } record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -29744,7 +30056,7 @@ fn aiur_fn_311( _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_311] = [__v_17]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[311].weight(); } record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -29775,10 +30087,11 @@ fn aiur_fn_312( unconstrained: bool, ) -> Result<[G; OUT_312], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -29786,24 +30099,24 @@ fn aiur_fn_312( 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_312] = [__v_6]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[312].weight(); } record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[296].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[296].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[312].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[312].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_312] = [__v_10]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[312].weight(); } record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -29814,7 +30127,7 @@ fn aiur_fn_312( break '__mc_0 [__v_11]; }, 1u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[313].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[313].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -29828,14 +30141,14 @@ fn aiur_fn_312( 1u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_312] = [__v_12]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[312].weight(); } record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[312].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[312].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_312] = [__v_12]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[312].weight(); } record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -29864,9 +30177,10 @@ fn aiur_fn_313( unconstrained: bool, ) -> Result<[G; OUT_313], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -29874,11 +30188,11 @@ fn aiur_fn_313( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_313] = [__v_5]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[313].weight(); } record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; match __v_5.as_canonical_u64() { @@ -29890,14 +30204,14 @@ fn aiur_fn_313( 0u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_313] = [__v_10]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[313].weight(); } record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[313].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[313].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_313] = [__v_10]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[313].weight(); } record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -29924,11 +30238,12 @@ fn aiur_fn_314( unconstrained: bool, ) -> Result<[G; OUT_314], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -29936,41 +30251,41 @@ fn aiur_fn_314( 1u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_314] = [__v_7]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[314].weight(); } record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[296].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[296].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[314].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_314] = [__v_11]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[314].weight(); } record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[315].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_314] = [__v_12]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[314].weight(); } record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[314].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_314] = [__v_12]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[314].weight(); } record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -29999,10 +30314,11 @@ fn aiur_fn_315( unconstrained: bool, ) -> Result<[G; OUT_315], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -30010,11 +30326,11 @@ fn aiur_fn_315( 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_315] = [__v_6]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[315].weight(); } record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { @@ -30027,14 +30343,14 @@ fn aiur_fn_315( 0u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_315] = [__v_10]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[315].weight(); } record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[315].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_315] = [__v_10]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[315].weight(); } record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -30043,10 +30359,10 @@ fn aiur_fn_315( } }, _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[315].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_315] = [__v_9]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[315].weight(); } record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -30070,9 +30386,10 @@ fn aiur_fn_316( unconstrained: bool, ) -> Result<[G; OUT_316], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -30080,11 +30397,11 @@ fn aiur_fn_316( 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_316] = [__v_5]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[316].weight(); } record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -30096,7 +30413,7 @@ fn aiur_fn_316( break '__mc_0 [__v_8]; }, _ => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[312].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[312].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, @@ -30107,24 +30424,24 @@ fn aiur_fn_316( 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_316] = [__v_9]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[316].weight(); } record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[317].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[317].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[317].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_316] = [__v_10]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[316].weight(); } record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[316].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_316] = [__v_10]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[316].weight(); } record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -30156,10 +30473,11 @@ fn aiur_fn_317( unconstrained: bool, ) -> Result<[G; OUT_317], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -30167,29 +30485,29 @@ fn aiur_fn_317( 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_317] = [__v_6]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[317].weight(); } record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[314].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_317] = [__v_9]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[317].weight(); } record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[317].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[317].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[317].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_317] = [__v_9]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[317].weight(); } record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -30216,30 +30534,31 @@ fn aiur_fn_318( unconstrained: bool, ) -> Result<[G; OUT_318], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_18, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[308].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[308].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_318] = [__v_19]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[318].weight(); } record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -30254,19 +30573,20 @@ fn aiur_fn_319( unconstrained: bool, ) -> Result<[G; OUT_319], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_319] = [__v_3]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[319].weight(); } record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -30274,18 +30594,18 @@ fn aiur_fn_319( 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_319] = [__v_6]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[319].weight(); } record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[318].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[318].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[316].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_319] = [__v_8]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[319].weight(); } record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -30307,26 +30627,27 @@ fn aiur_fn_320( unconstrained: bool, ) -> Result<[G; OUT_320], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_320] = [__v_3]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[320].weight(); } record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[318].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[318].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[311].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_320] = [__v_5]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[320].weight(); } record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -30346,14 +30667,15 @@ fn aiur_fn_321( unconstrained: bool, ) -> Result<[G; OUT_321], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[326].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[326].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[326].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[326].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -30362,12 +30684,12 @@ fn aiur_fn_321( match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_321] = [__v_1]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[321].weight(); } record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_321] = [__v_0]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[321].weight(); } record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -30376,19 +30698,19 @@ fn aiur_fn_321( } }, _ => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[322].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[322].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_321] = [__v_6]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[321].weight(); } record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[322].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[322].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_321] = [__v_4]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[321].weight(); } record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -30405,61 +30727,62 @@ fn aiur_fn_322( unconstrained: bool, ) -> Result<[G; OUT_322], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_322] = [__v_0]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[322].weight(); } record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_322] = [__v_1]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[322].weight(); } record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_322] = [__v_0]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[322].weight(); } record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_322] = [__v_1]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[322].weight(); } record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_322] = [__v_0]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[322].weight(); } record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[325].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[325].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[325].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_322] = [__v_11]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[322].weight(); } record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -30493,6 +30816,7 @@ fn aiur_fn_323( unconstrained: bool, ) -> Result<[G; OUT_323], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = (__v_0 - __v_1); @@ -30500,17 +30824,17 @@ fn aiur_fn_323( 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_323] = [__v_3]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -30518,88 +30842,88 @@ fn aiur_fn_323( 0u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 2u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); let __ret: [G; OUT_323] = [__v_11]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); let __ret: [G; OUT_323] = [__v_11]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 4u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -30610,13 +30934,13 @@ fn aiur_fn_323( 0u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_323] = [__v_10]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_323] = [__v_10]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -30624,7 +30948,7 @@ fn aiur_fn_323( _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -30648,28 +30972,29 @@ fn aiur_fn_324( unconstrained: bool, ) -> Result<[G; OUT_324], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_324] = [__v_6]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_324] = [__v_6]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -30680,7 +31005,7 @@ fn aiur_fn_324( _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_324] = [__v_5]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -30697,17 +31022,18 @@ fn aiur_fn_325( unconstrained: bool, ) -> Result<[G; OUT_325], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[327].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[327].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -30715,12 +31041,12 @@ fn aiur_fn_325( match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_325] = [__v_1]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[325].weight(); } record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_325] = [__v_0]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[325].weight(); } record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -30730,9 +31056,9 @@ fn aiur_fn_325( }, 0u64 => { let __v_9: G = G::from_u64(2); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_325] = [__v_10]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[325].weight(); } record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -30752,8 +31078,9 @@ fn aiur_fn_326( unconstrained: bool, ) -> Result<[G; OUT_326], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -30762,11 +31089,11 @@ fn aiur_fn_326( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); let __ret: [G; OUT_326] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[326].weight(); } record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[326].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[326].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -30775,14 +31102,14 @@ fn aiur_fn_326( let __v_7: G = G::from_u64(1); let __v_8: G = (__v_5 + __v_7); let __ret: [G; OUT_326] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[326].weight(); } record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __ret: [G; OUT_326] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[326].weight(); } record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -30791,7 +31118,7 @@ fn aiur_fn_326( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __ret: [G; OUT_326] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[326].weight(); } record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -30808,9 +31135,10 @@ fn aiur_fn_327( unconstrained: bool, ) -> Result<[G; OUT_327], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -30818,16 +31146,16 @@ fn aiur_fn_327( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[327].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_327] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[327].weight(); } record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_327] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[327].weight(); } record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -30844,9 +31172,10 @@ fn aiur_fn_328( unconstrained: bool, ) -> Result<[G; OUT_328], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -30854,54 +31183,54 @@ fn aiur_fn_328( 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_328] = [__v_7]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[328].weight(); } record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[321].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_328] = [__v_5]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[328].weight(); } record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[293].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[321].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_328] = [__v_6]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[328].weight(); } record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_328] = [__v_1]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[328].weight(); } record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_328] = [__v_0]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[328].weight(); } record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(3); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_328] = [__v_11]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[328].weight(); } record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -30930,8 +31259,9 @@ fn aiur_fn_329( unconstrained: bool, ) -> Result<[G; OUT_329], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -30939,49 +31269,49 @@ fn aiur_fn_329( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_329] = [__v_6]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[329].weight(); } record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_329] = [__v_6]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[329].weight(); } record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_329] = [__v_7]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[329].weight(); } record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[321].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_329] = [__v_6]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[329].weight(); } record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[328].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[328].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[328].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_329] = [__v_6]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[329].weight(); } record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31001,9 +31331,10 @@ fn aiur_fn_330( unconstrained: bool, ) -> Result<[G; OUT_330], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -31011,48 +31342,48 @@ fn aiur_fn_330( 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_330] = [__v_7]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[330].weight(); } record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_330] = [__v_8]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[330].weight(); } record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[321].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_330] = [__v_7]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[330].weight(); } record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[328].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[328].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[328].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_330] = [__v_7]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[330].weight(); } record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_330] = [__v_5]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[330].weight(); } record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31072,9 +31403,10 @@ fn aiur_fn_331( unconstrained: bool, ) -> Result<[G; OUT_331], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -31082,20 +31414,20 @@ fn aiur_fn_331( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_331] = [__v_7]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[331].weight(); } record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[331].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[331].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[331].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_331] = unsafe { *(record.function_queries[331].output_at(__i).as_ptr() as *const [G; OUT_331]) }; __ret }, _ => aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_331] = [__v_8]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[331].weight(); } record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31115,23 +31447,24 @@ fn aiur_fn_332( unconstrained: bool, ) -> Result<[G; OUT_332], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_332] = [__v_0]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[332].weight(); } record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_332] = [__v_5]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[332].weight(); } record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -31148,9 +31481,10 @@ fn aiur_fn_333( unconstrained: bool, ) -> Result<[G; OUT_333], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -31159,95 +31493,95 @@ fn aiur_fn_333( 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_333] = [__v_8]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[333].weight(); } record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_333] = [__v_9]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[333].weight(); } record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[331].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[331].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[331].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_331] = unsafe { *(record.function_queries[331].output_at(__i).as_ptr() as *const [G; OUT_331]) }; __ret }, _ => aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_333] = [__v_9]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[333].weight(); } record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_6: G = G::from_u64(3); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_333] = [__v_10]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[333].weight(); } record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_6: G = G::from_u64(4); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_333] = [__v_10]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[333].weight(); } record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __v_6: G = G::from_u64(5); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_333] = [__v_10]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[333].weight(); } record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(6); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_333] = [__v_10]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[333].weight(); } record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_333] = [__v_8]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[333].weight(); } record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_333] = [__v_8]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[333].weight(); } record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31267,9 +31601,10 @@ fn aiur_fn_334( unconstrained: bool, ) -> Result<[G; OUT_334], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -31282,7 +31617,7 @@ fn aiur_fn_334( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -31297,19 +31632,19 @@ fn aiur_fn_334( 1u64 => { let __v_22: G = G::from_u64(1); let __ret: [G; OUT_334] = [__v_22]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_334] = [__v_22]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -31324,24 +31659,24 @@ fn aiur_fn_334( 1u64 => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_334] = [__v_22]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_12(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } } else { aiur_fn_12(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[12].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[12].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => aiur_fn_12(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[334].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_334] = [__v_23]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_334] = [__v_23]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31371,15 +31706,16 @@ fn aiur_fn_335( unconstrained: bool, ) -> Result<[G; OUT_335], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -31387,19 +31723,19 @@ fn aiur_fn_335( 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_335] = [__v_8]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[335].weight(); } record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_335] = [__v_8]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[335].weight(); } record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -31407,23 +31743,23 @@ fn aiur_fn_335( 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_335] = [__v_8]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[335].weight(); } record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_8: G = (__v_3 - __v_6); match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[335].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[335].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_335] = [__v_9]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[335].weight(); } record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_335] = [__v_9]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[335].weight(); } record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -31450,6 +31786,7 @@ fn aiur_fn_336( unconstrained: bool, ) -> Result<[G; OUT_336], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -31458,16 +31795,16 @@ fn aiur_fn_336( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[334].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_336] = [__v_4]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[336].weight(); } record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_336] = [__v_4]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[336].weight(); } record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -31475,16 +31812,16 @@ fn aiur_fn_336( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[335].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[335].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_336] = [__v_4]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[336].weight(); } record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_336] = [__v_4]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[336].weight(); } record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -31506,8 +31843,9 @@ fn aiur_fn_337( unconstrained: bool, ) -> Result<[G; OUT_337], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -31517,76 +31855,76 @@ fn aiur_fn_337( let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 + __v_5); let __ret: [G; OUT_337] = [__v_6]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_337] = [__v_5]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_337] = [__v_5]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_337] = [__v_5]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[339].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_337] = [__v_7]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[340].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[340].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[339].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_337] = [__v_8]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[340].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[340].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[339].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_337] = [__v_8]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_337] = [__v_5]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_337] = [__v_5]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31606,23 +31944,24 @@ fn aiur_fn_338( unconstrained: bool, ) -> Result<[G; OUT_338], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[339].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[340].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[340].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[339].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_338] = [__v_8]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[338].weight(); } record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -31637,18 +31976,19 @@ fn aiur_fn_339( unconstrained: bool, ) -> Result<[G; OUT_339], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_339] = [__v_1]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[339].weight(); } record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_339] = [__v_0]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[339].weight(); } record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31668,19 +32008,20 @@ fn aiur_fn_340( unconstrained: bool, ) -> Result<[G; OUT_340], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_340] = [__v_1]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[340].weight(); } record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 - __v_1); let __ret: [G; OUT_340] = [__v_2]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[340].weight(); } record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -31697,18 +32038,19 @@ fn aiur_fn_341( unconstrained: bool, ) -> Result<[G; OUT_341], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_341] = [__v_0]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[341].weight(); } record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_341] = [__v_1]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[341].weight(); } record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31728,11 +32070,12 @@ fn aiur_fn_342( unconstrained: bool, ) -> Result<[G; OUT_342], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; let __ret: [G; OUT_342] = [__v_2]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[342].weight(); } record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -31747,10 +32090,11 @@ fn aiur_fn_343( unconstrained: bool, ) -> Result<[G; OUT_343], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -31762,13 +32106,13 @@ fn aiur_fn_343( 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_343] = [__v_8]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_8: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; let __ret: [G; OUT_343] = [__v_8]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31779,36 +32123,36 @@ fn aiur_fn_343( 1u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_343] = [__v_8]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_343] = [__v_8]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31817,31 +32161,31 @@ fn aiur_fn_343( } }, 4u64 => { - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[344].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[344].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[345].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_343] = [__v_7]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31861,17 +32205,18 @@ fn aiur_fn_344( unconstrained: bool, ) -> Result<[G; OUT_344], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_344] = [__v_5]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[344].weight(); } record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -31879,10 +32224,10 @@ fn aiur_fn_344( let __v_6: G = (__v_2 + __v_5); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_344] = [__v_9]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[344].weight(); } record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31902,28 +32247,29 @@ fn aiur_fn_345( unconstrained: bool, ) -> Result<[G; OUT_345], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_345] = [__v_6]; - if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[345].weight(); } record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_345] = [__v_7]; - if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[345].weight(); } record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -31931,10 +32277,10 @@ fn aiur_fn_345( let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_345] = [__v_11]; - if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[345].weight(); } record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -31959,16 +32305,17 @@ fn aiur_fn_346( unconstrained: bool, ) -> Result<[G; OUT_346], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[341].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[347].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[347].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_347] = unsafe { *(record.function_queries[347].output_at(__i).as_ptr() as *const [G; OUT_347]) }; __ret }, _ => aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_346] = [__v_4]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[346].weight(); } record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -31983,26 +32330,27 @@ fn aiur_fn_347( unconstrained: bool, ) -> Result<[G; OUT_347], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[348].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[348].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_348] = unsafe { *(record.function_queries[348].output_at(__i).as_ptr() as *const [G; OUT_348]) }; __ret }, _ => aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_347] = [__v_2]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[347].weight(); } record.function_queries[347].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[347].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[347].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_347] = unsafe { *(record.function_queries[347].output_at(__i).as_ptr() as *const [G; OUT_347]) }; __ret }, _ => aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); let __ret: [G; OUT_347] = [__v_7]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[347].weight(); } record.function_queries[347].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -32022,21 +32370,22 @@ fn aiur_fn_348( unconstrained: bool, ) -> Result<[G; OUT_348], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[349].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[349].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[349].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_349] = unsafe { *(record.function_queries[349].output_at(__i).as_ptr() as *const [G; OUT_349]) }; __ret }, _ => aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_4 + __v_6); let __ret: [G; OUT_348] = [__v_7]; - if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[348].weight(); } record.function_queries[348].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -32056,34 +32405,35 @@ fn aiur_fn_349( unconstrained: bool, ) -> Result<[G; OUT_349], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_349] = [__v_2]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[349].weight(); } record.function_queries[349].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[348].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[348].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_348] = unsafe { *(record.function_queries[348].output_at(__i).as_ptr() as *const [G; OUT_348]) }; __ret }, _ => aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_349] = [__v_2]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[349].weight(); } record.function_queries[349].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[349].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[349].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[349].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_349] = unsafe { *(record.function_queries[349].output_at(__i).as_ptr() as *const [G; OUT_349]) }; __ret }, _ => aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); let __ret: [G; OUT_349] = [__v_7]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[349].weight(); } record.function_queries[349].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -32105,38 +32455,39 @@ fn aiur_fn_350( unconstrained: bool, ) -> Result<[G; OUT_350], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_350] = [__v_4]; - if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[350].weight(); } record.function_queries[350].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_350] = [__v_0]; - if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[350].weight(); } record.function_queries[350].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[341].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[347].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[347].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_347] = unsafe { *(record.function_queries[347].output_at(__i).as_ptr() as *const [G; OUT_347]) }; __ret }, _ => aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_350] = [__v_7]; - if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[350].weight(); } record.function_queries[350].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -32158,26 +32509,27 @@ fn aiur_fn_351( unconstrained: bool, ) -> Result<[G; OUT_351], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(4294967295); let __ret: [G; OUT_351] = [__v_6]; - if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[351].weight(); } record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[352].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[352].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[352].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_352] = unsafe { *(record.function_queries[352].output_at(__i).as_ptr() as *const [G; OUT_352]) }; __ret }, _ => aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_351] = [__v_6]; - if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[351].weight(); } record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -32194,28 +32546,29 @@ fn aiur_fn_352( unconstrained: bool, ) -> Result<[G; OUT_352], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4294967295); let __ret: [G; OUT_352] = [__v_7]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_7: G = (__v_3 - __v_1); let __ret: [G; OUT_352] = [__v_7]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -32226,58 +32579,58 @@ fn aiur_fn_352( 1u64 => { let __v_6: G = G::from_u64(4294967295); let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(4294967295); let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(4294967295); let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[341].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_8]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[353].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[353].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[354].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_6]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -32297,19 +32650,20 @@ fn aiur_fn_353( unconstrained: bool, ) -> Result<[G; OUT_353], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 + __v_4); - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[341].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_353] = [__v_7]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[353].weight(); } record.function_queries[353].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -32324,24 +32678,25 @@ fn aiur_fn_354( unconstrained: bool, ) -> Result<[G; OUT_354], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[341].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[341].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_354] = [__v_10]; - if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[354].weight(); } record.function_queries[354].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -32356,31 +32711,32 @@ fn aiur_fn_355( unconstrained: bool, ) -> Result<[G; OUT_355], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_355] = [__v_0]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[355].weight(); } record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_355] = [__v_0]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[355].weight(); } record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_356(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[356].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[356].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_356] = unsafe { *(record.function_queries[356].output_at(__i).as_ptr() as *const [G; OUT_356]) }; __ret }, _ => aiur_fn_356(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_355] = [__v_5]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[355].weight(); } record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -32402,100 +32758,101 @@ fn aiur_fn_356( unconstrained: bool, ) -> Result<[G; OUT_356], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[357].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[357].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[357].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => aiur_fn_357(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_356] = [__v_7]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_356] = [__v_9]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_356] = [__v_9]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_356] = [__v_11]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_356] = [__v_13]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_356] = [__v_13]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[358].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_356] = [__v_7]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_356] = [__v_9]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_356] = [__v_9]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -32515,6 +32872,7 @@ fn aiur_fn_357( unconstrained: bool, ) -> Result<[G; OUT_357], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -32523,18 +32881,18 @@ fn aiur_fn_357( 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_357] = [__v_6]; - if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[357].weight(); } record.function_queries[357].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = (__v_0 + __v_1); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_357] = [__v_7]; - if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[357].weight(); } record.function_queries[357].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -32554,23 +32912,24 @@ fn aiur_fn_358( unconstrained: bool, ) -> Result<[G; OUT_358], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_358] = [__v_11]; - if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[358].weight(); } record.function_queries[358].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -32585,31 +32944,32 @@ fn aiur_fn_359( unconstrained: bool, ) -> Result<[G; OUT_359], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_359] = [__v_0]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[359].weight(); } record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_359] = [__v_0]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[359].weight(); } record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_360(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[360].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[360].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_360] = unsafe { *(record.function_queries[360].output_at(__i).as_ptr() as *const [G; OUT_360]) }; __ret }, _ => aiur_fn_360(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_359] = [__v_5]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[359].weight(); } record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -32631,10 +32991,11 @@ fn aiur_fn_360( unconstrained: bool, ) -> Result<[G; OUT_360], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -32645,16 +33006,16 @@ fn aiur_fn_360( match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_360] = [__v_0]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = (__v_4 - __v_1); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_360] = [__v_11]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -32665,89 +33026,89 @@ fn aiur_fn_360( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_360] = [__v_9]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_360] = [__v_9]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_360] = [__v_11]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_360] = [__v_13]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_360] = [__v_13]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(6); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_360] = [__v_13]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_360] = [__v_9]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_360] = [__v_9]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -32767,9 +33128,10 @@ fn aiur_fn_361( unconstrained: bool, ) -> Result<[G; OUT_361], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -32781,68 +33143,68 @@ fn aiur_fn_361( 0u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_361] = [__v_7]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_361] = [__v_7]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_361] = [__v_7]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_361] = [__v_7]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[362].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_361] = [__v_6]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[362].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_361] = [__v_6]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[363].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_361] = [__v_6]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_361] = [__v_6]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_361] = [__v_6]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -32859,25 +33221,26 @@ fn aiur_fn_362( unconstrained: bool, ) -> Result<[G; OUT_362], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_362] = [__v_4]; - if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[362].weight(); } record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 + __v_4); - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_362] = [__v_6]; - if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[362].weight(); } record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -32894,36 +33257,37 @@ fn aiur_fn_363( unconstrained: bool, ) -> Result<[G; OUT_363], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_363] = [__v_5]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[363].weight(); } record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_363] = [__v_6]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[363].weight(); } record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 + __v_6); - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_363] = [__v_8]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[363].weight(); } record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -32942,38 +33306,39 @@ fn aiur_fn_364( unconstrained: bool, ) -> Result<[G; OUT_364], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_364] = [__v_0]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[364].weight(); } record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[365].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[365].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[365].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => aiur_fn_365(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_364] = [__v_6]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[364].weight(); } record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_364] = [__v_9]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[364].weight(); } record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -32995,100 +33360,101 @@ fn aiur_fn_365( unconstrained: bool, ) -> Result<[G; OUT_365], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[366].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[366].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_366] = unsafe { *(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366]) }; __ret }, _ => aiur_fn_366(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_365] = [__v_7]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_365] = [__v_9]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_365] = [__v_9]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_365] = [__v_11]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_365] = [__v_13]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_365] = [__v_13]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[367].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_365] = [__v_7]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_365] = [__v_9]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_365] = [__v_9]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -33108,18 +33474,19 @@ fn aiur_fn_366( unconstrained: bool, ) -> Result<[G; OUT_366], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_366] = [__v_6]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[366].weight(); } record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -33127,10 +33494,10 @@ fn aiur_fn_366( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_366] = [__v_6]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[366].weight(); } record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -33138,9 +33505,9 @@ fn aiur_fn_366( let __v_6: G = G::from_u64(1); let __v_7: G = (__v_0 - __v_6); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_366] = [__v_9]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[366].weight(); } record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -33162,23 +33529,24 @@ fn aiur_fn_367( unconstrained: bool, ) -> Result<[G; OUT_367], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_367] = [__v_11]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[367].weight(); } record.function_queries[367].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -33193,46 +33561,47 @@ fn aiur_fn_368( unconstrained: bool, ) -> Result<[G; OUT_368], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_368] = [__v_0]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[368].weight(); } record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_368] = [__v_0]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[368].weight(); } record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_6: G = (__v_2 + __v_3); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_370(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[370].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[370].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[370].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_370] = unsafe { *(record.function_queries[370].output_at(__i).as_ptr() as *const [G; OUT_370]) }; __ret }, _ => aiur_fn_370(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_368] = [__v_8]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[368].weight(); } record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = (__v_2 + __v_3); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_368] = [__v_9]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[368].weight(); } record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -33256,32 +33625,33 @@ fn aiur_fn_369( unconstrained: bool, ) -> Result<[G; OUT_369], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_369] = [__v_8]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[369].weight(); } record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = (__v_0 - __v_3); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_369] = [__v_9]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[369].weight(); } record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -33301,100 +33671,101 @@ fn aiur_fn_370( unconstrained: bool, ) -> Result<[G; OUT_370], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_369(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[369].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[369].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => aiur_fn_369(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_7]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_370] = [__v_9]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_370] = [__v_9]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_370] = [__v_11]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_370] = [__v_13]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_370] = [__v_13]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[371].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_370] = [__v_7]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_370] = [__v_9]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_370] = [__v_9]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -33414,23 +33785,24 @@ fn aiur_fn_371( unconstrained: bool, ) -> Result<[G; OUT_371], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_371] = [__v_11]; - if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[371].weight(); } record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -33445,35 +33817,36 @@ fn aiur_fn_372( unconstrained: bool, ) -> Result<[G; OUT_372], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 4u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[372].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __ret: [G; OUT_372] = [__v_12, __v_13, __v_14]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[372].weight(); } record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_372] = [__v_0, __v_2, __v_1]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[372].weight(); } record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -33483,7 +33856,7 @@ fn aiur_fn_372( }, _ => { let __ret: [G; OUT_372] = [__v_0, __v_2, __v_1]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[372].weight(); } record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -33500,47 +33873,48 @@ fn aiur_fn_373( unconstrained: bool, ) -> Result<[G; OUT_373], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[372].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_1, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_373] = [__v_10]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[373].weight(); } record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_373] = [__v_14]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[373].weight(); } record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_373] = [__v_12]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[373].weight(); } record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -33557,63 +33931,64 @@ fn aiur_fn_374( unconstrained: bool, ) -> Result<[G; OUT_374], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_10]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[374].weight(); } record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_373(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[373].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[373].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[373].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_373] = unsafe { *(record.function_queries[373].output_at(__i).as_ptr() as *const [G; OUT_373]) }; __ret }, _ => aiur_fn_373(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_7]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[374].weight(); } record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[393].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[393].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[393].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_393] = unsafe { *(record.function_queries[393].output_at(__i).as_ptr() as *const [G; OUT_393]) }; __ret }, _ => aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_7]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[374].weight(); } record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_9]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[374].weight(); } record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[375].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[375].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[375].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_375] = unsafe { *(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375]) }; __ret }, _ => aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_7]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[374].weight(); } record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_7]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[374].weight(); } record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -33630,40 +34005,41 @@ fn aiur_fn_375( unconstrained: bool, ) -> Result<[G; OUT_375], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[227].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[382].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_11]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[375].weight(); } record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[383].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[383].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_383] = unsafe { *(record.function_queries[383].output_at(__i).as_ptr() as *const [G; OUT_383]) }; __ret }, _ => aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; @@ -33679,32 +34055,32 @@ fn aiur_fn_375( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_30]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[375].weight(); } record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); - let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_29, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_30]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[375].weight(); } record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(8); - let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_17]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[375].weight(); } record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -33723,6 +34099,7 @@ fn aiur_fn_376( unconstrained: bool, ) -> Result<[G; OUT_376], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(116); let __v_1: G = G::from_u64(89); let __v_2: G = G::from_u64(54); @@ -33755,9 +34132,9 @@ fn aiur_fn_376( let __v_29: G = G::from_u64(86); let __v_30: G = G::from_u64(91); let __v_31: G = G::from_u64(151); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_376] = [__v_32]; - if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[376].weight(); } record.function_queries[376].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -33772,6 +34149,7 @@ fn aiur_fn_377( unconstrained: bool, ) -> Result<[G; OUT_377], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(171); let __v_1: G = G::from_u64(55); let __v_2: G = G::from_u64(118); @@ -33804,9 +34182,9 @@ fn aiur_fn_377( let __v_29: G = G::from_u64(179); let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(25); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_377] = [__v_32]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[377].weight(); } record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -33821,6 +34199,7 @@ fn aiur_fn_378( unconstrained: bool, ) -> Result<[G; OUT_378], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(57); let __v_1: G = G::from_u64(138); let __v_2: G = G::from_u64(119); @@ -33853,9 +34232,9 @@ fn aiur_fn_378( let __v_29: G = G::from_u64(242); let __v_30: G = G::from_u64(182); let __v_31: G = G::from_u64(49); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_378] = [__v_32]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[378].weight(); } record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -33870,6 +34249,7 @@ fn aiur_fn_379( unconstrained: bool, ) -> Result<[G; OUT_379], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(136); let __v_1: G = G::from_u64(38); let __v_2: G = G::from_u64(102); @@ -33902,9 +34282,9 @@ fn aiur_fn_379( let __v_29: G = G::from_u64(125); let __v_30: G = G::from_u64(236); let __v_31: G = G::from_u64(246); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_379] = [__v_32]; - if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[379].weight(); } record.function_queries[379].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -33919,6 +34299,7 @@ fn aiur_fn_380( unconstrained: bool, ) -> Result<[G; OUT_380], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(141); let __v_1: G = G::from_u64(196); let __v_2: G = G::from_u64(169); @@ -33951,9 +34332,9 @@ fn aiur_fn_380( let __v_29: G = G::from_u64(139); let __v_30: G = G::from_u64(123); let __v_31: G = G::from_u64(208); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_380] = [__v_32]; - if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[380].weight(); } record.function_queries[380].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -33968,6 +34349,7 @@ fn aiur_fn_381( unconstrained: bool, ) -> Result<[G; OUT_381], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(18); let __v_1: G = G::from_u64(73); let __v_2: G = G::from_u64(132); @@ -34000,9 +34382,9 @@ fn aiur_fn_381( let __v_29: G = G::from_u64(176); let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(22); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_381] = [__v_32]; - if let Some(result) = record.function_queries[381].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[381].weight(); } record.function_queries[381].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -34017,13 +34399,14 @@ fn aiur_fn_382( unconstrained: bool, ) -> Result<[G; OUT_382], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = []; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[376].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { @@ -34031,24 +34414,24 @@ fn aiur_fn_382( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_382] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = []; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[377].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { @@ -34056,13 +34439,13 @@ fn aiur_fn_382( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_382] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(5); let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -34072,35 +34455,35 @@ fn aiur_fn_382( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_382] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; let __v_28: G = __loaded[3]; match __v_25.as_canonical_u64() { 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; @@ -34108,11 +34491,11 @@ fn aiur_fn_382( match __v_29.as_canonical_u64() { 4u64 => { let __v_33: G = G::from_u64(8); - let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_35: G = G::from_u64(4); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_38: G = __loaded[0]; let __v_39: G = __loaded[1]; let __v_40: G = __loaded[2]; @@ -34120,47 +34503,47 @@ fn aiur_fn_382( match __v_38.as_canonical_u64() { 4u64 => { let __v_42: G = G::from_u64(8); - let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_44: G = G::from_u64(4); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; let __hit = record.function_queries[378].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[378].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[378].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_378] = unsafe { *(record.function_queries[378].output_at(__i).as_ptr() as *const [G; OUT_378]) }; __ret }, _ => aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 4] = [__v_47, __v_48, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 4] = [__v_47, __v_48, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_54: G = G::from_u64(4); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_54, __v_26, __v_53, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_26, __v_53, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_57: G = G::from_u64(2); let __v_58: G = G::from_u64(0); - let __v_59: G = { let __values: [G; 4] = [__v_57, __v_7, __v_8, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 4] = [__v_57, __v_7, __v_8, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); - let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_16, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_16, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_63: G = G::from_u64(3); let __v_64: G = G::from_u64(0); - let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_56, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_56, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_66: G = G::from_u64(3); let __v_67: G = G::from_u64(0); - let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_37, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_37, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_69: G = G::from_u64(3); let __v_70: G = G::from_u64(0); - let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_46, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_46, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_72: G = G::from_u64(3); let __v_73: G = G::from_u64(0); - let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_75: G = G::from_u64(5); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_74, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; let __ret: [G; OUT_382] = [__v_77, __v_78]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -34168,9 +34551,9 @@ fn aiur_fn_382( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_382] = [__v_42, __v_46]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -34180,9 +34563,9 @@ fn aiur_fn_382( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_382] = [__v_33, __v_37]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -34192,9 +34575,9 @@ fn aiur_fn_382( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_382] = [__v_29, __v_33]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -34208,9 +34591,9 @@ fn aiur_fn_382( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_382] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -34220,9 +34603,9 @@ fn aiur_fn_382( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_382] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -34241,18 +34624,19 @@ fn aiur_fn_383( unconstrained: bool, ) -> Result<[G; OUT_383], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_383] = [__v_5]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[383].weight(); } record.function_queries[383].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -34261,14 +34645,14 @@ fn aiur_fn_383( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_383] = [__v_15]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[383].weight(); } record.function_queries[383].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -34285,9 +34669,10 @@ fn aiur_fn_384( unconstrained: bool, ) -> Result<[G; OUT_384], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -34295,20 +34680,20 @@ fn aiur_fn_384( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_384] = [__v_7]; - if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[384].weight(); } record.function_queries[384].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_384] = [__v_8]; - if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[384].weight(); } record.function_queries[384].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -34328,20 +34713,21 @@ fn aiur_fn_385( unconstrained: bool, ) -> Result<[G; OUT_385], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; let __hit = record.function_queries[145].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[145].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[144].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -34353,32 +34739,32 @@ fn aiur_fn_385( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_385] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_17, __v_20]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -34386,9 +34772,9 @@ fn aiur_fn_385( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_385] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -34406,34 +34792,34 @@ fn aiur_fn_385( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_385] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -34441,9 +34827,9 @@ fn aiur_fn_385( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_385] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -34451,11 +34837,11 @@ fn aiur_fn_385( } }, _ => { - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[260].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_385] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -34474,47 +34860,48 @@ fn aiur_fn_386( unconstrained: bool, ) -> Result<[G; OUT_386], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_386] = [__v_2]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[386].weight(); } record.function_queries[386].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_386] = [__v_2]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[386].weight(); } record.function_queries[386].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_386] = [__v_17]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[386].weight(); } record.function_queries[386].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -34539,10 +34926,11 @@ fn aiur_fn_387( unconstrained: bool, ) -> Result<[G; OUT_387], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[144].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { @@ -34550,9 +34938,9 @@ fn aiur_fn_387( break '__mc_0 [__v_3]; }, _ => { - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; let __hit = record.function_queries[145].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[145].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { @@ -34560,9 +34948,9 @@ fn aiur_fn_387( break '__mc_0 [__v_5]; }, _ => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -34570,9 +34958,9 @@ fn aiur_fn_387( break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; let __hit = record.function_queries[159].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[159].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[159].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -34580,9 +34968,9 @@ fn aiur_fn_387( break '__mc_0 [__v_9]; }, _ => { - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; let __hit = record.function_queries[160].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { @@ -34590,9 +34978,9 @@ fn aiur_fn_387( break '__mc_0 [__v_11]; }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { @@ -34600,9 +34988,9 @@ fn aiur_fn_387( break '__mc_0 [__v_13]; }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { @@ -34610,9 +34998,9 @@ fn aiur_fn_387( break '__mc_0 [__v_15]; }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { @@ -34620,9 +35008,9 @@ fn aiur_fn_387( break '__mc_0 [__v_17]; }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { @@ -34630,9 +35018,9 @@ fn aiur_fn_387( break '__mc_0 [__v_19]; }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { @@ -34640,9 +35028,9 @@ fn aiur_fn_387( break '__mc_0 [__v_21]; }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { @@ -34650,9 +35038,9 @@ fn aiur_fn_387( break '__mc_0 [__v_23]; }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[165].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { @@ -34660,9 +35048,9 @@ fn aiur_fn_387( break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[166].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { @@ -34670,9 +35058,9 @@ fn aiur_fn_387( break '__mc_0 [__v_27]; }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { @@ -34680,9 +35068,9 @@ fn aiur_fn_387( break '__mc_0 [__v_29]; }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[168].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { @@ -34690,9 +35078,9 @@ fn aiur_fn_387( break '__mc_0 [__v_31]; }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; match __v_32.as_canonical_u64() { 1u64 => { @@ -34740,63 +35128,63 @@ fn aiur_fn_387( 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_387] = [__v_4]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[215].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(2); let __ret: [G; OUT_387] = [__v_5]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[193].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[193].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(3); let __ret: [G; OUT_387] = [__v_6]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[180].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4); let __ret: [G; OUT_387] = [__v_7]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[511].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[511].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[511].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_511] = unsafe { *(record.function_queries[511].output_at(__i).as_ptr() as *const [G; OUT_511]) }; __ret }, _ => aiur_fn_511(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_387] = [__v_8]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(6); let __ret: [G; OUT_387] = [__v_9]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_387] = [__v_9]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -34823,61 +35211,62 @@ fn aiur_fn_388( unconstrained: bool, ) -> Result<[G; OUT_388], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[387].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[385].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[385].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[385].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_385] = unsafe { *(record.function_queries[385].output_at(__i).as_ptr() as *const [G; OUT_385]) }; __ret }, _ => aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_388] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[216].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[216].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_388] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_388] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[183].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_388] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[517].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[517].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[517].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_517] = unsafe { *(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517]) }; __ret }, _ => aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_388] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[249].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_388] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -34885,9 +35274,9 @@ fn aiur_fn_388( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_388] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -34904,34 +35293,35 @@ fn aiur_fn_389( unconstrained: bool, ) -> Result<[G; OUT_389], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; let __hit = record.function_queries[380].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[380].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[380].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[390].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[390].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[390].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_390] = unsafe { *(record.function_queries[390].output_at(__i).as_ptr() as *const [G; OUT_390]) }; __ret }, _ => aiur_fn_390(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_389] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[389].weight(); } record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; let __hit = record.function_queries[381].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[381].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_381] = unsafe { *(record.function_queries[381].output_at(__i).as_ptr() as *const [G; OUT_381]) }; __ret }, _ => aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[391].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[391].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[391].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_391] = unsafe { *(record.function_queries[391].output_at(__i).as_ptr() as *const [G; OUT_391]) }; __ret }, _ => aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_389] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[389].weight(); } record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -34939,9 +35329,9 @@ fn aiur_fn_389( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_389] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[389].weight(); } record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -34960,9 +35350,10 @@ fn aiur_fn_390( unconstrained: bool, ) -> Result<[G; OUT_390], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(6); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -34972,34 +35363,34 @@ fn aiur_fn_390( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_390] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[390].weight(); } record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[392].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(6); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_390] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[390].weight(); } record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -35007,9 +35398,9 @@ fn aiur_fn_390( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_390] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[390].weight(); } record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35028,9 +35419,10 @@ fn aiur_fn_391( unconstrained: bool, ) -> Result<[G; OUT_391], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(5); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -35040,34 +35432,34 @@ fn aiur_fn_391( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_391] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[391].weight(); } record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[392].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(5); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_391] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[391].weight(); } record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -35075,9 +35467,9 @@ fn aiur_fn_391( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_391] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[391].weight(); } record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35096,27 +35488,28 @@ fn aiur_fn_392( unconstrained: bool, ) -> Result<[G; OUT_392], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; let __hit = record.function_queries[379].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[379].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[379].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_379] = unsafe { *(record.function_queries[379].output_at(__i).as_ptr() as *const [G; OUT_379]) }; __ret }, _ => aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(3); let __v_13: G = (__v_11 - __v_12); @@ -35124,10 +35517,10 @@ fn aiur_fn_392( 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_392] = [__v_14, __v_16]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[392].weight(); } record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -35135,9 +35528,9 @@ fn aiur_fn_392( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_392] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[392].weight(); } record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35147,9 +35540,9 @@ fn aiur_fn_392( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_392] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[392].weight(); } record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35159,9 +35552,9 @@ fn aiur_fn_392( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_392] = [__v_9, __v_13]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[392].weight(); } record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35178,31 +35571,32 @@ fn aiur_fn_393( unconstrained: bool, ) -> Result<[G; OUT_393], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[388].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[388].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[388].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_388] = unsafe { *(record.function_queries[388].output_at(__i).as_ptr() as *const [G; OUT_388]) }; __ret }, _ => aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_7]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_393] = [__v_6]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -35217,52 +35611,52 @@ fn aiur_fn_393( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[394].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[394].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[394].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_394] = unsafe { *(record.function_queries[394].output_at(__i).as_ptr() as *const [G; OUT_394]) }; __ret }, _ => aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_22]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_23]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_20]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[389].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[389].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[389].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_389] = unsafe { *(record.function_queries[389].output_at(__i).as_ptr() as *const [G; OUT_389]) }; __ret }, _ => aiur_fn_389(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_22]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_22]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35273,10 +35667,10 @@ fn aiur_fn_393( let __v_22: G = (__v_21 + __v_12); let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_16.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_10, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[405].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[405].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[405].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_405] = unsafe { *(record.function_queries[405].output_at(__i).as_ptr() as *const [G; OUT_405]) }; __ret }, _ => aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[397].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[397].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_397] = unsafe { *(record.function_queries[397].output_at(__i).as_ptr() as *const [G; OUT_397]) }; __ret }, _ => aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; break '__mc_0 [__v_25, __v_26]; @@ -35292,45 +35686,45 @@ fn aiur_fn_393( match __v_23.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_393] = [__v_24]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[619].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[401].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[401].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[401].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; match __v_26.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_27, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_28]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { match __v_16.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_393] = [__v_27]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[404].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[404].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_404] = unsafe { *(record.function_queries[404].output_at(__i).as_ptr() as *const [G; OUT_404]) }; __ret }, _ => aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_30]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_393] = [__v_27]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35338,10 +35732,10 @@ fn aiur_fn_393( } }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_28]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35349,10 +35743,10 @@ fn aiur_fn_393( } }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_20]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35371,10 +35765,11 @@ fn aiur_fn_394( unconstrained: bool, ) -> Result<[G; OUT_394], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[395].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[395].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[395].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_395] = unsafe { *(record.function_queries[395].output_at(__i).as_ptr() as *const [G; OUT_395]) }; __ret }, _ => aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -35382,7 +35777,7 @@ fn aiur_fn_394( let __v_7: G = __r_arr[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { @@ -35391,23 +35786,23 @@ fn aiur_fn_394( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_394] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[394].weight(); } record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); - let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_394] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[394].weight(); } record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35417,9 +35812,9 @@ fn aiur_fn_394( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_394] = [__v_8, __v_12]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[394].weight(); } record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35436,9 +35831,10 @@ fn aiur_fn_395( unconstrained: bool, ) -> Result<[G; OUT_395], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -35447,18 +35843,18 @@ fn aiur_fn_395( 4u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[395].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[395].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[395].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_395] = unsafe { *(record.function_queries[395].output_at(__i).as_ptr() as *const [G; OUT_395]) }; __ret }, _ => aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __v_11: G = __r_arr[3]; let __v_12: G = __r_arr[4]; let __ret: [G; OUT_395] = [__v_8, __v_9, __v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[395].weight(); } record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -35473,7 +35869,7 @@ fn aiur_fn_395( let __v_13: G = (__v_1 - __v_12); let __v_14: G = (__v_13 - __v_7); let __ret: [G; OUT_395] = [__v_11, __v_1, __v_3, __v_4, __v_14]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[395].weight(); } record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -35511,11 +35907,11 @@ fn aiur_fn_395( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __ret: [G; OUT_395] = [__v_11, __v_12, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[395].weight(); } record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35555,11 +35951,11 @@ fn aiur_fn_395( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); - let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __ret: [G; OUT_395] = [__v_10, __v_11, __v_44, __v_45, __v_46]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[395].weight(); } record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35599,11 +35995,11 @@ fn aiur_fn_395( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __ret: [G; OUT_395] = [__v_6, __v_7, __v_40, __v_41, __v_42]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[395].weight(); } record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35620,8 +36016,9 @@ fn aiur_fn_396( unconstrained: bool, ) -> Result<[G; OUT_396], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -35630,58 +36027,58 @@ fn aiur_fn_396( 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[143].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_396] = [__v_12]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[396].weight(); } record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(7); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[144].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_396] = [__v_21]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[396].weight(); } record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_396] = [__v_0]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[396].weight(); } record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_396] = [__v_0]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[396].weight(); } record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35698,6 +36095,7 @@ fn aiur_fn_397( unconstrained: bool, ) -> Result<[G; OUT_397], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -35707,7 +36105,7 @@ fn aiur_fn_397( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -35720,9 +36118,9 @@ fn aiur_fn_397( let __v_14: G = (__v_4 + __v_5); let __v_15: G = (__v_3 + __v_14); let __v_16: G = (__v_2 + __v_15); - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -35730,15 +36128,15 @@ fn aiur_fn_397( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_397] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[397].weight(); } record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[398].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[398].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[398].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_398] = unsafe { *(record.function_queries[398].output_at(__i).as_ptr() as *const [G; OUT_398]) }; __ret }, _ => aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { @@ -35746,31 +36144,31 @@ fn aiur_fn_397( let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); - let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_397] = [__v_21, __v_25]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[397].weight(); } record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_12, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_3 + __v_4); let __v_23: G = (__v_2 + __v_22); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); let __v_26: G = (__v_16 + __v_25); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_28, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_397] = [__v_30, __v_31]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[397].weight(); } record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35784,9 +36182,9 @@ fn aiur_fn_397( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_397] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[397].weight(); } record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35803,38 +36201,39 @@ fn aiur_fn_398( unconstrained: bool, ) -> Result<[G; OUT_398], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_398] = [__v_14]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[398].weight(); } record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -35849,27 +36248,27 @@ fn aiur_fn_398( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[551].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[551].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(2); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_32, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_398] = [__v_34]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[398].weight(); } record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(0); let __ret: [G; OUT_398] = [__v_27]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[398].weight(); } record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35879,7 +36278,7 @@ fn aiur_fn_398( _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_398] = [__v_13]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[398].weight(); } record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35896,26 +36295,27 @@ fn aiur_fn_399( unconstrained: bool, ) -> Result<[G; OUT_399], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 + __v_4); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_399] = [__v_13]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[399].weight(); } record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -35930,23 +36330,24 @@ fn aiur_fn_400( unconstrained: bool, ) -> Result<[G; OUT_400], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -35961,26 +36362,26 @@ fn aiur_fn_400( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_13, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_23, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[400].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[400].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[400].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_400] = [__v_24]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[400].weight(); } record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_400] = [__v_2]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[400].weight(); } record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_400] = [__v_2]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[400].weight(); } record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -35997,6 +36398,7 @@ fn aiur_fn_401( unconstrained: bool, ) -> Result<[G; OUT_401], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -36010,7 +36412,7 @@ fn aiur_fn_401( let __v_10: G = (__v_4 + __v_5); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_14.as_canonical_u64() { @@ -36019,45 +36421,45 @@ fn aiur_fn_401( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_401] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[401].weight(); } record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[258].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[258].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[258].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_401] = [__v_17, __v_16]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[401].weight(); } record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_18, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[400].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[400].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[400].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[396].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[396].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[396].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_396] = unsafe { *(record.function_queries[396].output_at(__i).as_ptr() as *const [G; OUT_396]) }; __ret }, _ => aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[402].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[402].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[402].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_402] = unsafe { *(record.function_queries[402].output_at(__i).as_ptr() as *const [G; OUT_402]) }; __ret }, _ => aiur_fn_402(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[403].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[403].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[403].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_403] = unsafe { *(record.function_queries[403].output_at(__i).as_ptr() as *const [G; OUT_403]) }; __ret }, _ => aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_24, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); if (__v_29 != __v_30) { @@ -36065,40 +36467,40 @@ fn aiur_fn_401( } match __v_26.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[399].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[399].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[399].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_399] = unsafe { *(record.function_queries[399].output_at(__i).as_ptr() as *const [G; OUT_399]) }; __ret }, _ => aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __ret: [G; OUT_401] = [__v_32, __v_33]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[401].weight(); } record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_28, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = (__v_3 + __v_4); let __v_33: G = (__v_2 + __v_32); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_35 - __v_27); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_25, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_12 + __v_38); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_31, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_41, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_42, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(1); let __ret: [G; OUT_401] = [__v_44, __v_43]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[401].weight(); } record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -36107,13 +36509,13 @@ fn aiur_fn_401( } }, _ => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[399].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[399].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[399].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_399] = unsafe { *(record.function_queries[399].output_at(__i).as_ptr() as *const [G; OUT_399]) }; __ret }, _ => aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_401] = [__v_27, __v_28]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[401].weight(); } record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36134,20 +36536,21 @@ fn aiur_fn_402( unconstrained: bool, ) -> Result<[G; OUT_402], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -36163,10 +36566,10 @@ fn aiur_fn_402( match __v_8.as_canonical_u64() { 6u64 => { let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[460].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[460].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[460].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_460] = unsafe { *(record.function_queries[460].output_at(__i).as_ptr() as *const [G; OUT_460]) }; __ret }, _ => aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_402] = [__v_20, __v_13, __v_21, __v_2]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[402].weight(); } record.function_queries[402].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -36204,12 +36607,12 @@ fn aiur_fn_402( let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(0); let __v_53: G = G::from_u64(0); - let __v_54: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_55: G = G::from_u64(1); let __v_56: G = G::from_u64(1); - let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_402] = [__v_20, __v_21, __v_54, __v_57]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[402].weight(); } record.function_queries[402].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36249,12 +36652,12 @@ fn aiur_fn_402( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 32] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 32] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_402] = [__v_7, __v_8, __v_41, __v_44]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[402].weight(); } record.function_queries[402].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36271,9 +36674,10 @@ fn aiur_fn_403( unconstrained: bool, ) -> Result<[G; OUT_403], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -36286,9 +36690,9 @@ fn aiur_fn_403( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_403] = [__v_7, __v_8, __v_12]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[403].weight(); } record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -36299,16 +36703,16 @@ fn aiur_fn_403( 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_403] = [__v_8, __v_4, __v_5]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[403].weight(); } record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[403].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[403].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[403].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_403] = unsafe { *(record.function_queries[403].output_at(__i).as_ptr() as *const [G; OUT_403]) }; __ret }, _ => aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __ret: [G; OUT_403] = [__v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[403].weight(); } record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36332,6 +36736,7 @@ fn aiur_fn_404( unconstrained: bool, ) -> Result<[G; OUT_404], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -36341,7 +36746,7 @@ fn aiur_fn_404( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -36353,13 +36758,13 @@ fn aiur_fn_404( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_404] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -36371,9 +36776,9 @@ fn aiur_fn_404( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_404] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { @@ -36382,7 +36787,7 @@ fn aiur_fn_404( let __v_19: G = (__v_3 + __v_4); let __v_20: G = (__v_19 + __v_5); let __v_21: G = (__v_20 + __v_6); - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[405].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[405].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[405].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_405] = unsafe { *(record.function_queries[405].output_at(__i).as_ptr() as *const [G; OUT_405]) }; __ret }, _ => aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { @@ -36391,15 +36796,15 @@ fn aiur_fn_404( let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_404] = [__v_24, __v_28]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; @@ -36420,7 +36825,7 @@ fn aiur_fn_404( 0u64 => { match __v_29.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[407].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[407].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[407].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_407] = unsafe { *(record.function_queries[407].output_at(__i).as_ptr() as *const [G; OUT_407]) }; __ret }, _ => aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; match __v_39.as_canonical_u64() { 1u64 => { @@ -36428,19 +36833,19 @@ fn aiur_fn_404( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); - let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_404] = [__v_40, __v_44]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { @@ -36448,15 +36853,15 @@ fn aiur_fn_404( let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __v_48: G = { let __values: [G; 4] = [__v_45, __v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = { let __values: [G; 4] = [__v_45, __v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_404] = [__v_44, __v_48]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_40, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_44, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_44, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[466].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[466].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[466].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_466] = unsafe { *(record.function_queries[466].output_at(__i).as_ptr() as *const [G; OUT_466]) }; __ret }, _ => aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { @@ -36464,32 +36869,32 @@ fn aiur_fn_404( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); - let __v_50: G = { let __values: [G; 4] = [__v_47, __v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = { let __values: [G; 4] = [__v_47, __v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_404] = [__v_46, __v_50]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_12, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = (__v_3 + __v_4); let __v_48: G = (__v_47 + __v_5); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_46, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[406].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[406].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[406].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_406] = unsafe { *(record.function_queries[406].output_at(__i).as_ptr() as *const [G; OUT_406]) }; __ret }, _ => aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_21 + __v_53); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_52, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_56, __v_57]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36503,9 +36908,9 @@ fn aiur_fn_404( let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_404] = [__v_39, __v_43]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36515,9 +36920,9 @@ fn aiur_fn_404( let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_404] = [__v_39, __v_43]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36527,9 +36932,9 @@ fn aiur_fn_404( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_404] = [__v_37, __v_41]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36560,21 +36965,22 @@ fn aiur_fn_405( unconstrained: bool, ) -> Result<[G; OUT_405], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -36583,7 +36989,7 @@ fn aiur_fn_405( 2u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_405] = [__v_12, __v_9]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[405].weight(); } record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -36620,9 +37026,9 @@ fn aiur_fn_405( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_405] = [__v_12, __v_45]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[405].weight(); } record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36661,15 +37067,15 @@ fn aiur_fn_405( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_405] = [__v_6, __v_39]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[405].weight(); } record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -36678,11 +37084,11 @@ fn aiur_fn_405( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[405].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[405].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[405].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_405] = unsafe { *(record.function_queries[405].output_at(__i).as_ptr() as *const [G; OUT_405]) }; __ret }, _ => aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_405] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[405].weight(); } record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -36719,9 +37125,9 @@ fn aiur_fn_405( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_405] = [__v_6, __v_39]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[405].weight(); } record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36740,6 +37146,7 @@ fn aiur_fn_406( unconstrained: bool, ) -> Result<[G; OUT_406], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -36749,21 +37156,21 @@ fn aiur_fn_406( match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_406] = [__v_0]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[406].weight(); } record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(8); - let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_4 + __v_11); - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[406].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[406].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[406].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_406] = unsafe { *(record.function_queries[406].output_at(__i).as_ptr() as *const [G; OUT_406]) }; __ret }, _ => aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_406] = [__v_13]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[406].weight(); } record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36780,10 +37187,11 @@ fn aiur_fn_407( unconstrained: bool, ) -> Result<[G; OUT_407], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -36798,19 +37206,19 @@ fn aiur_fn_407( let __v_13: G = __loaded[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[408].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[408].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_408] = unsafe { *(record.function_queries[408].output_at(__i).as_ptr() as *const [G; OUT_408]) }; __ret }, _ => aiur_fn_408(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[409].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[409].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[409].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_409] = unsafe { *(record.function_queries[409].output_at(__i).as_ptr() as *const [G; OUT_409]) }; __ret }, _ => aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_407] = [__v_16]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[407].weight(); } record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_407] = [__v_14]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[407].weight(); } record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36827,9 +37235,10 @@ fn aiur_fn_408( unconstrained: bool, ) -> Result<[G; OUT_408], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -36882,20 +37291,20 @@ fn aiur_fn_408( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[291].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[291].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_50]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[408].weight(); } record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); - let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_408] = [__v_54]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[408].weight(); } record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36914,6 +37323,7 @@ fn aiur_fn_409( unconstrained: bool, ) -> Result<[G; OUT_409], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -36925,13 +37335,13 @@ fn aiur_fn_409( 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_409] = [__v_7]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[409].weight(); } record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -36946,24 +37356,24 @@ fn aiur_fn_409( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[410].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[410].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[410].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_410] = unsafe { *(record.function_queries[410].output_at(__i).as_ptr() as *const [G; OUT_410]) }; __ret }, _ => aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_20, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[411].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[411].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[411].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_411] = unsafe { *(record.function_queries[411].output_at(__i).as_ptr() as *const [G; OUT_411]) }; __ret }, _ => aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); let __ret: [G; OUT_409] = [__v_22]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[409].weight(); } record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); let __v_23: G = (__v_5 + __v_22); - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[409].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[409].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[409].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_409] = unsafe { *(record.function_queries[409].output_at(__i).as_ptr() as *const [G; OUT_409]) }; __ret }, _ => aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_409] = [__v_24]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[409].weight(); } record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36971,7 +37381,7 @@ fn aiur_fn_409( _ => { let __v_20: G = G::from_u64(1); let __ret: [G; OUT_409] = [__v_20]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[409].weight(); } record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -36990,16 +37400,17 @@ fn aiur_fn_410( unconstrained: bool, ) -> Result<[G; OUT_410], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_410] = [__v_0]; - if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[410].weight(); } record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -37008,15 +37419,15 @@ fn aiur_fn_410( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[410].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[410].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[410].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_410] = unsafe { *(record.function_queries[410].output_at(__i).as_ptr() as *const [G; OUT_410]) }; __ret }, _ => aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_410] = [__v_8]; - if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[410].weight(); } record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_410] = [__v_0]; - if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[410].weight(); } record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37035,29 +37446,30 @@ fn aiur_fn_411( unconstrained: bool, ) -> Result<[G; OUT_411], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_411] = [__v_7]; - if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[411].weight(); } record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[411].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[411].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[411].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_411] = unsafe { *(record.function_queries[411].output_at(__i).as_ptr() as *const [G; OUT_411]) }; __ret }, _ => aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_411] = [__v_7]; - if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[411].weight(); } record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37065,7 +37477,7 @@ fn aiur_fn_411( _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_411] = [__v_6]; - if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[411].weight(); } record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37082,103 +37494,104 @@ fn aiur_fn_412( unconstrained: bool, ) -> Result<[G; OUT_412], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[413].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[413].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_6]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_412] = [__v_7]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_412] = [__v_8]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_8]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37186,16 +37599,16 @@ fn aiur_fn_412( } }, 8u64 => { - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_412] = [__v_6]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_412] = [__v_6]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37212,9 +37625,10 @@ fn aiur_fn_413( unconstrained: bool, ) -> Result<[G; OUT_413], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -37222,24 +37636,24 @@ fn aiur_fn_413( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_413] = [__v_5]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[413].weight(); } record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_413] = [__v_6]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[413].weight(); } record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[413].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[413].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_413] = [__v_6]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[413].weight(); } record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37261,9 +37675,10 @@ fn aiur_fn_414( unconstrained: bool, ) -> Result<[G; OUT_414], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -37271,41 +37686,41 @@ fn aiur_fn_414( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_414] = [__v_0]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[414].weight(); } record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_414] = [__v_0]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[414].weight(); } record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_414] = [__v_0]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[414].weight(); } record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_414] = [__v_0]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[414].weight(); } record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_414] = [__v_0]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[414].weight(); } record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_414] = [__v_11]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[414].weight(); } record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37322,15 +37737,16 @@ fn aiur_fn_415( unconstrained: bool, ) -> Result<[G; OUT_415], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_415] = [__v_5]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[415].weight(); } record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -37345,9 +37761,10 @@ fn aiur_fn_416( unconstrained: bool, ) -> Result<[G; OUT_416], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -37355,41 +37772,41 @@ fn aiur_fn_416( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_416] = [__v_0]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[416].weight(); } record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_416] = [__v_0]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[416].weight(); } record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_416] = [__v_0]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[416].weight(); } record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_416] = [__v_0]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[416].weight(); } record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_416] = [__v_0]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[416].weight(); } record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[417].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_416] = [__v_11]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[416].weight(); } record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37406,99 +37823,100 @@ fn aiur_fn_417( unconstrained: bool, ) -> Result<[G; OUT_417], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[417].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_10]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[372].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_14]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_11, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[417].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_18]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[417].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_16]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[417].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_9]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[418].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[418].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[418].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_418] = unsafe { *(record.function_queries[418].output_at(__i).as_ptr() as *const [G; OUT_418]) }; __ret }, _ => aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_7]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[419].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[419].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_419] = unsafe { *(record.function_queries[419].output_at(__i).as_ptr() as *const [G; OUT_419]) }; __ret }, _ => aiur_fn_419(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_7]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_7]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37515,27 +37933,28 @@ fn aiur_fn_418( unconstrained: bool, ) -> Result<[G; OUT_418], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[416].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[416].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_416] = unsafe { *(record.function_queries[416].output_at(__i).as_ptr() as *const [G; OUT_416]) }; __ret }, _ => aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[383].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[383].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_383] = unsafe { *(record.function_queries[383].output_at(__i).as_ptr() as *const [G; OUT_383]) }; __ret }, _ => aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -37551,28 +37970,28 @@ fn aiur_fn_418( match __v_14.as_canonical_u64() { 6u64 => { let __v_26: G = (__v_20 + __v_1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[417].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_418] = [__v_28]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[418].weight(); } record.function_queries[418].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_418] = [__v_26]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[418].weight(); } record.function_queries[418].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_418] = [__v_13]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[418].weight(); } record.function_queries[418].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37589,14 +38008,15 @@ fn aiur_fn_419( unconstrained: bool, ) -> Result<[G; OUT_419], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -37611,33 +38031,33 @@ fn aiur_fn_419( let __v_17: G = __loaded[11]; match __v_6.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[619].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[401].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[401].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[401].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_20, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[416].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[416].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_416] = unsafe { *(record.function_queries[416].output_at(__i).as_ptr() as *const [G; OUT_416]) }; __ret }, _ => aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_419] = [__v_21]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[419].weight(); } record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_419] = [__v_21]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[419].weight(); } record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_419] = [__v_18]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[419].weight(); } record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37654,9 +38074,10 @@ fn aiur_fn_420( unconstrained: bool, ) -> Result<[G; OUT_420], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -37664,41 +38085,41 @@ fn aiur_fn_420( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[420].weight(); } record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[420].weight(); } record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[420].weight(); } record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[420].weight(); } record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_420] = [__v_0]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[420].weight(); } record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_420] = [__v_11]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[420].weight(); } record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37715,15 +38136,16 @@ fn aiur_fn_421( unconstrained: bool, ) -> Result<[G; OUT_421], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_421] = [__v_5]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[421].weight(); } record.function_queries[421].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -37738,63 +38160,64 @@ fn aiur_fn_422( unconstrained: bool, ) -> Result<[G; OUT_422], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_422] = [__v_10]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[422].weight(); } record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[423].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_422] = [__v_7]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[422].weight(); } record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[425].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_422] = [__v_7]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[422].weight(); } record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_422] = [__v_9]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[422].weight(); } record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[424].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[424].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[424].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_424] = unsafe { *(record.function_queries[424].output_at(__i).as_ptr() as *const [G; OUT_424]) }; __ret }, _ => aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_422] = [__v_7]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[422].weight(); } record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_422] = [__v_7]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[422].weight(); } record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37811,47 +38234,48 @@ fn aiur_fn_423( unconstrained: bool, ) -> Result<[G; OUT_423], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[372].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_1, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_423] = [__v_10]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[423].weight(); } record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_423] = [__v_14]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[423].weight(); } record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_423] = [__v_12]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[423].weight(); } record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37868,40 +38292,41 @@ fn aiur_fn_424( unconstrained: bool, ) -> Result<[G; OUT_424], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[227].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[382].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_11]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[424].weight(); } record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[383].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[383].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_383] = unsafe { *(record.function_queries[383].output_at(__i).as_ptr() as *const [G; OUT_383]) }; __ret }, _ => aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; @@ -37917,32 +38342,32 @@ fn aiur_fn_424( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_30]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[424].weight(); } record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); - let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_29, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_30]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[424].weight(); } record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(8); - let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_17]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[424].weight(); } record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -37961,22 +38386,23 @@ fn aiur_fn_425( unconstrained: bool, ) -> Result<[G; OUT_425], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[387].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[388].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[388].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[388].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_388] = unsafe { *(record.function_queries[388].output_at(__i).as_ptr() as *const [G; OUT_388]) }; __ret }, _ => aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; break '__mc_0 [__v_8, __v_9]; @@ -37986,13 +38412,13 @@ fn aiur_fn_425( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_0 [__v_8, __v_12]; }, } }, _ => { - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[388].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[388].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[388].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_388] = unsafe { *(record.function_queries[388].output_at(__i).as_ptr() as *const [G; OUT_388]) }; __ret }, _ => aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; break '__mc_0 [__v_6, __v_7]; @@ -38003,21 +38429,21 @@ fn aiur_fn_425( let __v_7: G = __mc_out___mc_0[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_8]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_425] = [__v_7]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -38032,43 +38458,43 @@ fn aiur_fn_425( let __v_20: G = __loaded[11]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_12, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[394].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[394].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[394].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_394] = unsafe { *(record.function_queries[394].output_at(__i).as_ptr() as *const [G; OUT_394]) }; __ret }, _ => aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_23]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_23]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[389].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[389].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[389].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_389] = unsafe { *(record.function_queries[389].output_at(__i).as_ptr() as *const [G; OUT_389]) }; __ret }, _ => aiur_fn_389(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_23]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_23]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -38079,10 +38505,10 @@ fn aiur_fn_425( let __v_23: G = (__v_22 + __v_13); let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_11, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_11, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[405].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[405].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[405].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_405] = unsafe { *(record.function_queries[405].output_at(__i).as_ptr() as *const [G; OUT_405]) }; __ret }, _ => aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[397].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[397].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_397] = unsafe { *(record.function_queries[397].output_at(__i).as_ptr() as *const [G; OUT_397]) }; __ret }, _ => aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; break '__mc_1 [__v_26, __v_27]; @@ -38098,45 +38524,45 @@ fn aiur_fn_425( match __v_24.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_425] = [__v_25]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[619].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[401].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[401].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[401].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_28, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_28, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_29]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { match __v_17.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_425] = [__v_28]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[404].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[404].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_404] = unsafe { *(record.function_queries[404].output_at(__i).as_ptr() as *const [G; OUT_404]) }; __ret }, _ => aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_30, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_30, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_31]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_425] = [__v_28]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -38144,10 +38570,10 @@ fn aiur_fn_425( } }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_29]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -38155,10 +38581,10 @@ fn aiur_fn_425( } }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_21]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -38177,17 +38603,18 @@ fn aiur_fn_426( unconstrained: bool, ) -> Result<[G; OUT_426], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_426] = [__v_6]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[426].weight(); } record.function_queries[426].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -38202,6 +38629,7 @@ fn aiur_fn_427( unconstrained: bool, ) -> Result<[G; OUT_427], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -38217,42 +38645,42 @@ fn aiur_fn_427( match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_427] = [__v_1]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -38272,6 +38700,7 @@ fn aiur_fn_428( unconstrained: bool, ) -> Result<[G; OUT_428], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -38287,42 +38716,42 @@ fn aiur_fn_428( match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_428] = [__v_2]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -38342,47 +38771,48 @@ fn aiur_fn_429( unconstrained: bool, ) -> Result<[G; OUT_429], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_5 + __v_9); let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_12]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_429] = [__v_14]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -38395,25 +38825,25 @@ fn aiur_fn_429( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[427].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[427].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[427].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_427] = unsafe { *(record.function_queries[427].output_at(__i).as_ptr() as *const [G; OUT_427]) }; __ret }, _ => aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[428].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_22, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_24]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -38421,16 +38851,16 @@ fn aiur_fn_429( match __v_9.as_canonical_u64() { 5u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_14]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -38438,10 +38868,10 @@ fn aiur_fn_429( match __v_14.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_19]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -38453,68 +38883,68 @@ fn aiur_fn_429( }, 4u64 => { let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_11, __v_5, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_5, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_429] = [__v_13]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[431].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[431].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[431].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[431].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[328].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[328].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[328].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_429] = [__v_15]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_10]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; let __hit = record.function_queries[378].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[378].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[378].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_378] = unsafe { *(record.function_queries[378].output_at(__i).as_ptr() as *const [G; OUT_378]) }; __ret }, _ => aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_429] = [__v_14]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[214].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_429] = [__v_14]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -38523,23 +38953,23 @@ fn aiur_fn_429( } }, 8u64 => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; @@ -38558,9 +38988,9 @@ fn aiur_fn_429( match __v_17.as_canonical_u64() { 5u64 => { let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; @@ -38579,15 +39009,15 @@ fn aiur_fn_429( } match __v_31.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_33, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[432].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[433].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[433].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[433].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_433] = unsafe { *(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433]) }; __ret }, _ => aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_47]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -38622,43 +39052,44 @@ fn aiur_fn_430( unconstrained: bool, ) -> Result<[G; OUT_430], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_10]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_430] = [__v_12]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -38671,25 +39102,25 @@ fn aiur_fn_430( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[427].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[427].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[427].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_427] = unsafe { *(record.function_queries[427].output_at(__i).as_ptr() as *const [G; OUT_427]) }; __ret }, _ => aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[428].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_20, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_22]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -38697,16 +39128,16 @@ fn aiur_fn_430( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_12]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -38714,10 +39145,10 @@ fn aiur_fn_430( match __v_12.as_canonical_u64() { 5u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_17]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -38729,68 +39160,68 @@ fn aiur_fn_430( }, 4u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_430] = [__v_11]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[431].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[431].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[431].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[431].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[328].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[328].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[328].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_430] = [__v_13]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_8]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; let __hit = record.function_queries[378].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[378].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[378].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_378] = unsafe { *(record.function_queries[378].output_at(__i).as_ptr() as *const [G; OUT_378]) }; __ret }, _ => aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_430] = [__v_12]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[214].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_430] = [__v_12]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -38799,23 +39230,23 @@ fn aiur_fn_430( } }, 8u64 => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -38834,9 +39265,9 @@ fn aiur_fn_430( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; @@ -38855,15 +39286,15 @@ fn aiur_fn_430( } match __v_29.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_31, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[432].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[433].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[433].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[433].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_433] = unsafe { *(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433]) }; __ret }, _ => aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_45]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -38898,11 +39329,12 @@ fn aiur_fn_431( unconstrained: bool, ) -> Result<[G; OUT_431], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -38910,13 +39342,13 @@ fn aiur_fn_431( match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_431] = [__v_4]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[431].weight(); } record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -38924,7 +39356,7 @@ fn aiur_fn_431( match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_431] = [__v_9]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[431].weight(); } record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -38946,38 +39378,39 @@ fn aiur_fn_432( unconstrained: bool, ) -> Result<[G; OUT_432], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_432] = [__v_0]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[432].weight(); } record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_2 - __v_12); - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[432].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_432] = [__v_14]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[432].weight(); } record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -39004,12 +39437,13 @@ fn aiur_fn_433( unconstrained: bool, ) -> Result<[G; OUT_433], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -39020,21 +39454,21 @@ fn aiur_fn_433( match __v_9.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_433] = [__v_6]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[433].weight(); } record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(8); - let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_2 + __v_14); - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[433].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[433].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[433].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_433] = unsafe { *(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433]) }; __ret }, _ => aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_433] = [__v_16]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[433].weight(); } record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39056,15 +39490,16 @@ fn aiur_fn_434( unconstrained: bool, ) -> Result<[G; OUT_434], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -39072,19 +39507,19 @@ fn aiur_fn_434( 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_434] = [__v_8]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[434].weight(); } record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_434] = [__v_8]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[434].weight(); } record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -39092,24 +39527,24 @@ fn aiur_fn_434( 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_434] = [__v_8]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[434].weight(); } record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_434] = [__v_9]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[434].weight(); } record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[434].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_434] = [__v_9]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[434].weight(); } record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39136,6 +39571,7 @@ fn aiur_fn_435( unconstrained: bool, ) -> Result<[G; OUT_435], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -39144,32 +39580,32 @@ fn aiur_fn_435( 0u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_435] = [__v_4]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[435].weight(); } record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[339].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[437].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_435] = [__v_10]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[435].weight(); } record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[436].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[436].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_435] = [__v_7]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[435].weight(); } record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39188,48 +39624,49 @@ fn aiur_fn_436( unconstrained: bool, ) -> Result<[G; OUT_436], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[341].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[341].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[437].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_12]; - if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[436].weight(); } record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_3 - __v_10); - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[437].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_436] = [__v_18]; - if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[436].weight(); } record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39246,23 +39683,24 @@ fn aiur_fn_437( unconstrained: bool, ) -> Result<[G; OUT_437], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[438].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_437] = [__v_4]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[437].weight(); } record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[438].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_437] = [__v_4]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[437].weight(); } record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39279,23 +39717,24 @@ fn aiur_fn_438( unconstrained: bool, ) -> Result<[G; OUT_438], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[439].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[439].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[439].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_439] = unsafe { *(record.function_queries[439].output_at(__i).as_ptr() as *const [G; OUT_439]) }; __ret }, _ => aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_438] = [__v_4]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[438].weight(); } record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[446].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[446].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_438] = [__v_4]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[438].weight(); } record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39312,23 +39751,24 @@ fn aiur_fn_439( unconstrained: bool, ) -> Result<[G; OUT_439], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -39338,33 +39778,33 @@ fn aiur_fn_439( let __v_15: G = (__v_8 - __v_12); match __v_15.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[434].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_439] = [__v_17]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[439].weight(); } record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[440].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_439] = [__v_20]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[439].weight(); } record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_439] = [__v_20]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[439].weight(); } record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39374,7 +39814,7 @@ fn aiur_fn_439( _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_439] = [__v_16]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[439].weight(); } record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39382,7 +39822,7 @@ fn aiur_fn_439( _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_439] = [__v_15]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[439].weight(); } record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39390,7 +39830,7 @@ fn aiur_fn_439( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_439] = [__v_11]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[439].weight(); } record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39407,16 +39847,17 @@ fn aiur_fn_440( unconstrained: bool, ) -> Result<[G; OUT_440], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -39424,19 +39865,19 @@ fn aiur_fn_440( 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_440] = [__v_9]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[440].weight(); } record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_440] = [__v_9]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[440].weight(); } record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -39444,24 +39885,24 @@ fn aiur_fn_440( 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_440] = [__v_9]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[440].weight(); } record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_440] = [__v_10]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[440].weight(); } record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[440].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_440] = [__v_10]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[440].weight(); } record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39488,8 +39929,9 @@ fn aiur_fn_441( unconstrained: bool, ) -> Result<[G; OUT_441], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -39498,33 +39940,33 @@ fn aiur_fn_441( 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_5]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[441].weight(); } record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_441] = [__v_5]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[441].weight(); } record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[143].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_6]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[441].weight(); } record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_441] = [__v_5]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[441].weight(); } record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39541,8 +39983,9 @@ fn aiur_fn_442( unconstrained: bool, ) -> Result<[G; OUT_442], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -39554,75 +39997,75 @@ fn aiur_fn_442( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_5, __v_9, __v_3]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_442] = [__v_5, __v_0, __v_8]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[144].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[442].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_14, __v_12, __v_15]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_442] = [__v_11, __v_0, __v_14]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -39631,23 +40074,23 @@ fn aiur_fn_442( 7u64 => { match __v_16.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[442].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_21, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[114].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_22, __v_20, __v_23]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); let __ret: [G; OUT_442] = [__v_22, __v_7, __v_17]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39656,9 +40099,9 @@ fn aiur_fn_442( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_442] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39667,9 +40110,9 @@ fn aiur_fn_442( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_442] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39678,9 +40121,9 @@ fn aiur_fn_442( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_442] = [__v_15, __v_0, __v_18]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39689,9 +40132,9 @@ fn aiur_fn_442( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_442] = [__v_13, __v_0, __v_16]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39700,9 +40143,9 @@ fn aiur_fn_442( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_442] = [__v_9, __v_0, __v_12]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39711,9 +40154,9 @@ fn aiur_fn_442( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_442] = [__v_5, __v_0, __v_8]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39730,12 +40173,13 @@ fn aiur_fn_443( unconstrained: bool, ) -> Result<[G; OUT_443], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[441].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[441].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_441] = unsafe { *(record.function_queries[441].output_at(__i).as_ptr() as *const [G; OUT_441]) }; __ret }, _ => aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[441].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[441].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_441] = unsafe { *(record.function_queries[441].output_at(__i).as_ptr() as *const [G; OUT_441]) }; __ret }, _ => aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 * __v_4); match __v_5.as_canonical_u64() { @@ -39743,15 +40187,15 @@ fn aiur_fn_443( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __ret: [G; OUT_443] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[443].weight(); } record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[442].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[442].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -39761,26 +40205,26 @@ fn aiur_fn_443( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __ret: [G; OUT_443] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[443].weight(); } record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[334].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __ret: [G; OUT_443] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[443].weight(); } record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_443] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[443].weight(); } record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39801,23 +40245,24 @@ fn aiur_fn_444( unconstrained: bool, ) -> Result<[G; OUT_444], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[445].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_444] = [__v_4]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[444].weight(); } record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[445].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_444] = [__v_4]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[444].weight(); } record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39834,10 +40279,11 @@ fn aiur_fn_445( unconstrained: bool, ) -> Result<[G; OUT_445], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -39846,20 +40292,20 @@ fn aiur_fn_445( 7u64 => { match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[224].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[224].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_224] = unsafe { *(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224]) }; __ret }, _ => aiur_fn_224(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[226].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_445] = [__v_9]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[445].weight(); } record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_445] = [__v_7]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[445].weight(); } record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39867,7 +40313,7 @@ fn aiur_fn_445( _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_445] = [__v_7]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[445].weight(); } record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39884,10 +40330,11 @@ fn aiur_fn_446( unconstrained: bool, ) -> Result<[G; OUT_446], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[445].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 1u64 => { @@ -39895,7 +40342,7 @@ fn aiur_fn_446( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[445].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -39906,14 +40353,14 @@ fn aiur_fn_446( 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_446] = [__v_5]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[446].weight(); } record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[447].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[447].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[447].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_447] = unsafe { *(record.function_queries[447].output_at(__i).as_ptr() as *const [G; OUT_447]) }; __ret }, _ => aiur_fn_447(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_446] = [__v_5]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[446].weight(); } record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39930,46 +40377,47 @@ fn aiur_fn_447( unconstrained: bool, ) -> Result<[G; OUT_447], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[416].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[416].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_416] = unsafe { *(record.function_queries[416].output_at(__i).as_ptr() as *const [G; OUT_416]) }; __ret }, _ => aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[416].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[416].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_416] = unsafe { *(record.function_queries[416].output_at(__i).as_ptr() as *const [G; OUT_416]) }; __ret }, _ => aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_447] = [__v_6]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[447].weight(); } record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[449].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[449].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[449].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_449] = unsafe { *(record.function_queries[449].output_at(__i).as_ptr() as *const [G; OUT_449]) }; __ret }, _ => aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_447] = [__v_7]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[447].weight(); } record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[439].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[439].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[439].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_439] = unsafe { *(record.function_queries[439].output_at(__i).as_ptr() as *const [G; OUT_439]) }; __ret }, _ => aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_447] = [__v_8]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[447].weight(); } record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[448].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[448].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => aiur_fn_448(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_447] = [__v_8]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[447].weight(); } record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -39990,48 +40438,49 @@ fn aiur_fn_448( unconstrained: bool, ) -> Result<[G; OUT_448], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_448] = [__v_8]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[448].weight(); } record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[449].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[449].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[449].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_449] = unsafe { *(record.function_queries[449].output_at(__i).as_ptr() as *const [G; OUT_449]) }; __ret }, _ => aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_448] = [__v_9]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[448].weight(); } record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[439].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[439].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[439].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_439] = unsafe { *(record.function_queries[439].output_at(__i).as_ptr() as *const [G; OUT_439]) }; __ret }, _ => aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_448] = [__v_10]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[448].weight(); } record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_450(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[450].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[450].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[450].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_450] = unsafe { *(record.function_queries[450].output_at(__i).as_ptr() as *const [G; OUT_450]) }; __ret }, _ => aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_448] = [__v_10]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[448].weight(); } record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40052,61 +40501,62 @@ fn aiur_fn_449( unconstrained: bool, ) -> Result<[G; OUT_449], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_449] = [__v_11]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_449] = [__v_11]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_449] = [__v_14]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_449] = [__v_12]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40114,35 +40564,35 @@ fn aiur_fn_449( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_449] = [__v_11]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 5u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_449] = [__v_14]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_449] = [__v_12]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40150,7 +40600,7 @@ fn aiur_fn_449( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_449] = [__v_11]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40158,7 +40608,7 @@ fn aiur_fn_449( _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_449] = [__v_7]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40175,6 +40625,7 @@ fn aiur_fn_450( unconstrained: bool, ) -> Result<[G; OUT_450], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -40185,62 +40636,62 @@ fn aiur_fn_450( 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_450] = [__v_6]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[464].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_450] = [__v_7]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[462].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[462].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[462].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_462] = unsafe { *(record.function_queries[462].output_at(__i).as_ptr() as *const [G; OUT_462]) }; __ret }, _ => aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_450] = [__v_8]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[458].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_450] = [__v_9]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[458].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_450] = [__v_10]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[443].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_450] = [__v_11]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(16); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; @@ -40248,14 +40699,14 @@ fn aiur_fn_450( 1u64 => { let __v_16: G = G::from_u64(1); let __ret: [G; OUT_450] = [__v_16]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_451(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[451].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[451].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[451].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_450] = [__v_16]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40284,37 +40735,38 @@ fn aiur_fn_451( unconstrained: bool, ) -> Result<[G; OUT_451], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(8); - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_451] = [__v_8]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[451].weight(); } record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[453].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[453].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[453].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_453] = unsafe { *(record.function_queries[453].output_at(__i).as_ptr() as *const [G; OUT_453]) }; __ret }, _ => aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_451] = [__v_9]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[451].weight(); } record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[457].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[457].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[457].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_457] = unsafe { *(record.function_queries[457].output_at(__i).as_ptr() as *const [G; OUT_457]) }; __ret }, _ => aiur_fn_457(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_451] = [__v_9]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[451].weight(); } record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40333,47 +40785,48 @@ fn aiur_fn_452( unconstrained: bool, ) -> Result<[G; OUT_452], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_452] = [__v_8]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[452].weight(); } record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 8u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_13 - __v_17); let __v_21: G = G::from_bool((__v_20 == G::ZERO)); @@ -40383,16 +40836,16 @@ fn aiur_fn_452( let __v_25: G = (__v_19 * __v_24); match __v_25.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[440].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_452] = [__v_26]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[452].weight(); } record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __ret: [G; OUT_452] = [__v_26]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[452].weight(); } record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40400,7 +40853,7 @@ fn aiur_fn_452( _ => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_452] = [__v_19]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[452].weight(); } record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40408,7 +40861,7 @@ fn aiur_fn_452( _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_452] = [__v_15]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[452].weight(); } record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40416,7 +40869,7 @@ fn aiur_fn_452( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_452] = [__v_11]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[452].weight(); } record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40435,35 +40888,36 @@ fn aiur_fn_453( unconstrained: bool, ) -> Result<[G; OUT_453], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(8); - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_453] = [__v_6]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[453].weight(); } record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_452(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[452].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[452].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[452].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_452] = unsafe { *(record.function_queries[452].output_at(__i).as_ptr() as *const [G; OUT_452]) }; __ret }, _ => aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_453] = [__v_7]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[453].weight(); } record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[454].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[454].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[454].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_454] = unsafe { *(record.function_queries[454].output_at(__i).as_ptr() as *const [G; OUT_454]) }; __ret }, _ => aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_453] = [__v_7]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[453].weight(); } record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40482,37 +40936,38 @@ fn aiur_fn_454( unconstrained: bool, ) -> Result<[G; OUT_454], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[453].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[453].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[453].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_453] = unsafe { *(record.function_queries[453].output_at(__i).as_ptr() as *const [G; OUT_453]) }; __ret }, _ => aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[453].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[453].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[453].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_453] = unsafe { *(record.function_queries[453].output_at(__i).as_ptr() as *const [G; OUT_453]) }; __ret }, _ => aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_454] = [__v_12]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[454].weight(); } record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_454] = [__v_12]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[454].weight(); } record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40520,7 +40975,7 @@ fn aiur_fn_454( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_454] = [__v_11]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[454].weight(); } record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40528,7 +40983,7 @@ fn aiur_fn_454( _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_454] = [__v_7]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[454].weight(); } record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40545,6 +41000,7 @@ fn aiur_fn_455( unconstrained: bool, ) -> Result<[G; OUT_455], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -40554,18 +41010,18 @@ fn aiur_fn_455( 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_455] = [__v_5, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -40577,287 +41033,287 @@ fn aiur_fn_455( 0u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_455] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_455] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_455] = [__v_13, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 2u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_7, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[434].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_455] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_455] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_455] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 5u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_455] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 7u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[336].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_455] = [__v_13, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 8u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = (__v_7 - __v_11); match __v_14.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_455] = [__v_15, __v_2]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_455] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40876,6 +41332,7 @@ fn aiur_fn_456( unconstrained: bool, ) -> Result<[G; OUT_456], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -40885,37 +41342,37 @@ fn aiur_fn_456( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __ret: [G; OUT_456] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[456].weight(); } record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 - __v_4); - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 - __v_7); match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_456] = [__v_9, __v_5]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[456].weight(); } record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[443].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_456] = [__v_10, __v_5]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[456].weight(); } record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(8); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -40923,15 +41380,15 @@ fn aiur_fn_456( 1u64 => { let __v_15: G = G::from_u64(1); let __ret: [G; OUT_456] = [__v_15, __v_5]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[456].weight(); } record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_456] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[456].weight(); } record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -40954,86 +41411,87 @@ fn aiur_fn_457( unconstrained: bool, ) -> Result<[G; OUT_457], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_457] = [__v_6]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[464].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_457] = [__v_7]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[462].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[462].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[462].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_462] = unsafe { *(record.function_queries[462].output_at(__i).as_ptr() as *const [G; OUT_462]) }; __ret }, _ => aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_457] = [__v_8]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[458].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_457] = [__v_9]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[458].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_457] = [__v_10]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[443].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_457] = [__v_11]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[461].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[461].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => aiur_fn_461(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_457] = [__v_13]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_467(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[467].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[467].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[467].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_467] = unsafe { *(record.function_queries[467].output_at(__i).as_ptr() as *const [G; OUT_467]) }; __ret }, _ => aiur_fn_467(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_457] = [__v_13]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41062,22 +41520,23 @@ fn aiur_fn_458( unconstrained: bool, ) -> Result<[G; OUT_458], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -41092,15 +41551,15 @@ fn aiur_fn_458( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_16 + __v_17); let __v_24: G = (__v_22 - __v_23); match __v_24.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[285].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; @@ -41124,41 +41583,41 @@ fn aiur_fn_458( 0u64 => { let __v_43: G = G::from_u64(0); let __ret: [G; OUT_458] = [__v_43]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[460].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[460].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[460].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_460] = unsafe { *(record.function_queries[460].output_at(__i).as_ptr() as *const [G; OUT_460]) }; __ret }, _ => aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[407].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[407].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[407].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_407] = unsafe { *(record.function_queries[407].output_at(__i).as_ptr() as *const [G; OUT_407]) }; __ret }, _ => aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(0); let __ret: [G; OUT_458] = [__v_45]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 0u64 => { let __v_48: G = G::from_u64(0); let __ret: [G; OUT_458] = [__v_48]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[459].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __ret: [G; OUT_458] = [__v_49]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41170,7 +41629,7 @@ fn aiur_fn_458( _ => { let __v_38: G = G::from_u64(0); let __ret: [G; OUT_458] = [__v_38]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41178,7 +41637,7 @@ fn aiur_fn_458( _ => { let __v_25: G = G::from_u64(0); let __ret: [G; OUT_458] = [__v_25]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41186,7 +41645,7 @@ fn aiur_fn_458( _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_458] = [__v_22]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41194,7 +41653,7 @@ fn aiur_fn_458( _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_458] = [__v_9]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41211,6 +41670,7 @@ fn aiur_fn_459( unconstrained: bool, ) -> Result<[G; OUT_459], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -41223,31 +41683,31 @@ fn aiur_fn_459( 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_459] = [__v_8]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[459].weight(); } record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_10: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_459] = [__v_13]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[459].weight(); } record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[459].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_459] = [__v_15]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[459].weight(); } record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41266,9 +41726,10 @@ fn aiur_fn_460( unconstrained: bool, ) -> Result<[G; OUT_460], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[289].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -41281,22 +41742,22 @@ fn aiur_fn_460( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[71].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[71].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_71] = unsafe { *(record.function_queries[71].output_at(__i).as_ptr() as *const [G; OUT_71]) }; __ret }, _ => aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[21].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[21].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_21] = unsafe { *(record.function_queries[21].output_at(__i).as_ptr() as *const [G; OUT_21]) }; __ret }, _ => aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_460] = [__v_25]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[460].weight(); } record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -41311,17 +41772,18 @@ fn aiur_fn_461( unconstrained: bool, ) -> Result<[G; OUT_461], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -41330,36 +41792,36 @@ fn aiur_fn_461( 4u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_461] = [__v_11]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[461].weight(); } record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[465].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[465].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_465] = unsafe { *(record.function_queries[465].output_at(__i).as_ptr() as *const [G; OUT_465]) }; __ret }, _ => aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_461] = [__v_11]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[461].weight(); } record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[465].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[465].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_465] = unsafe { *(record.function_queries[465].output_at(__i).as_ptr() as *const [G; OUT_465]) }; __ret }, _ => aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_461] = [__v_11]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[461].weight(); } record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_461] = [__v_11]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[461].weight(); } record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41378,29 +41840,30 @@ fn aiur_fn_462( unconstrained: bool, ) -> Result<[G; OUT_462], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[463].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_462] = [__v_6]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[462].weight(); } record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_462] = [__v_7]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[462].weight(); } record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41417,20 +41880,21 @@ fn aiur_fn_463( unconstrained: bool, ) -> Result<[G; OUT_463], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -41452,9 +41916,9 @@ fn aiur_fn_463( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; @@ -41473,13 +41937,13 @@ fn aiur_fn_463( 0u64 => { let __v_36: G = G::from_u64(1); let __ret: [G; OUT_463] = [__v_36]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_36]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41487,7 +41951,7 @@ fn aiur_fn_463( _ => { let __v_36: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_36]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41495,7 +41959,7 @@ fn aiur_fn_463( _ => { let __v_22: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_22]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41503,7 +41967,7 @@ fn aiur_fn_463( _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_20]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41511,7 +41975,7 @@ fn aiur_fn_463( _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_20]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41519,7 +41983,7 @@ fn aiur_fn_463( _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_463] = [__v_7]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41536,27 +42000,28 @@ fn aiur_fn_464( unconstrained: bool, ) -> Result<[G; OUT_464], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[466].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[466].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[466].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_466] = unsafe { *(record.function_queries[466].output_at(__i).as_ptr() as *const [G; OUT_466]) }; __ret }, _ => aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_464] = [__v_5]; - if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[464].weight(); } record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_464] = [__v_6]; - if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[464].weight(); } record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41573,48 +42038,49 @@ fn aiur_fn_465( unconstrained: bool, ) -> Result<[G; OUT_465], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_465] = [__v_11]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[465].weight(); } record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_465] = [__v_23]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[465].weight(); } record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41622,7 +42088,7 @@ fn aiur_fn_465( _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_465] = [__v_10]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[465].weight(); } record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41639,13 +42105,14 @@ fn aiur_fn_466( unconstrained: bool, ) -> Result<[G; OUT_466], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -41654,17 +42121,17 @@ fn aiur_fn_466( 1u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_5, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_466] = [__v_11]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[466].weight(); } record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_466] = [__v_8]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[466].weight(); } record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41681,13 +42148,14 @@ fn aiur_fn_467( unconstrained: bool, ) -> Result<[G; OUT_467], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[468].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[468].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[468].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_467] = [__v_3]; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[467].weight(); } record.function_queries[467].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -41702,17 +42170,18 @@ fn aiur_fn_468( unconstrained: bool, ) -> Result<[G; OUT_468], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -41724,13 +42193,13 @@ fn aiur_fn_468( 0u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41738,102 +42207,102 @@ fn aiur_fn_468( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 2u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[434].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[481].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[481].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[481].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[481].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_468] = [__v_13]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41841,75 +42310,75 @@ fn aiur_fn_468( } }, _ => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[481].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_14]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[465].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[465].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_465] = unsafe { *(record.function_queries[465].output_at(__i).as_ptr() as *const [G; OUT_465]) }; __ret }, _ => aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 5u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_14]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41917,7 +42386,7 @@ fn aiur_fn_468( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41925,39 +42394,39 @@ fn aiur_fn_468( 6u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_7]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[336].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[396].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[396].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[396].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_396] = unsafe { *(record.function_queries[396].output_at(__i).as_ptr() as *const [G; OUT_396]) }; __ret }, _ => aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = (__v_11 - __v_0); match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_13]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[468].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[468].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[468].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41965,30 +42434,30 @@ fn aiur_fn_468( } }, 8u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_13]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_13]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -41996,7 +42465,7 @@ fn aiur_fn_468( _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_12]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42004,7 +42473,7 @@ fn aiur_fn_468( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_468] = [__v_11]; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42026,6 +42495,7 @@ fn aiur_fn_469( unconstrained: bool, ) -> Result<[G; OUT_469], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -42034,7 +42504,7 @@ fn aiur_fn_469( 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_469] = [__v_4, __v_0, __v_1]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -42043,45 +42513,45 @@ fn aiur_fn_469( 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_469] = [__v_5, __v_0, __v_1]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[443].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_469] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[482].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[482].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[471].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[471].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[471].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_471] = unsafe { *(record.function_queries[471].output_at(__i).as_ptr() as *const [G; OUT_471]) }; __ret }, _ => aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[475].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[475].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[475].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_475] = unsafe { *(record.function_queries[475].output_at(__i).as_ptr() as *const [G; OUT_475]) }; __ret }, _ => aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42089,21 +42559,21 @@ fn aiur_fn_469( _ => { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[476].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[476].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[476].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => aiur_fn_476(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_477(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[477].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42128,6 +42598,7 @@ fn aiur_fn_470( unconstrained: bool, ) -> Result<[G; OUT_470], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -42143,13 +42614,13 @@ fn aiur_fn_470( match __v_0.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_470] = [__v_5]; - if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[470].weight(); } record.function_queries[470].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_470] = [__v_12]; - if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[470].weight(); } record.function_queries[470].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42166,15 +42637,16 @@ fn aiur_fn_471( unconstrained: bool, ) -> Result<[G; OUT_471], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -42187,9 +42659,9 @@ fn aiur_fn_471( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -42202,9 +42674,9 @@ fn aiur_fn_471( let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; let __v_31: G = __loaded[11]; - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[478].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[478].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_478] = unsafe { *(record.function_queries[478].output_at(__i).as_ptr() as *const [G; OUT_478]) }; __ret }, _ => aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[478].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[478].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_478] = unsafe { *(record.function_queries[478].output_at(__i).as_ptr() as *const [G; OUT_478]) }; __ret }, _ => aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; match __v_32.as_canonical_u64() { 0u64 => { @@ -42212,16 +42684,16 @@ fn aiur_fn_471( 0u64 => { let __v_34: G = G::from_u64(0); let __ret: [G; OUT_471] = [__v_34, __v_2, __v_3]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[471].weight(); } record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[473].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[473].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[473].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; let __ret: [G; OUT_471] = [__v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[471].weight(); } record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42229,49 +42701,49 @@ fn aiur_fn_471( _ => { match __v_33.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[472].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; let __ret: [G; OUT_471] = [__v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[471].weight(); } record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[470].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[470].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[470].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_470] = unsafe { *(record.function_queries[470].output_at(__i).as_ptr() as *const [G; OUT_470]) }; __ret }, _ => aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[470].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[470].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[470].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_470] = unsafe { *(record.function_queries[470].output_at(__i).as_ptr() as *const [G; OUT_470]) }; __ret }, _ => aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_36.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[472].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; let __ret: [G; OUT_471] = [__v_37, __v_38, __v_39]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[471].weight(); } record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_37: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_35.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_37.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[473].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[473].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[473].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __ret: [G; OUT_471] = [__v_38, __v_39, __v_40]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[471].weight(); } record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[474].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[474].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[474].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_474] = unsafe { *(record.function_queries[474].output_at(__i).as_ptr() as *const [G; OUT_474]) }; __ret }, _ => aiur_fn_474(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __ret: [G; OUT_471] = [__v_38, __v_39, __v_40]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[471].weight(); } record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42294,31 +42766,32 @@ fn aiur_fn_472( unconstrained: bool, ) -> Result<[G; OUT_472], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[480].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[480].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __ret: [G; OUT_472] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[472].weight(); } record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_472] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[472].weight(); } record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42335,31 +42808,32 @@ fn aiur_fn_473( unconstrained: bool, ) -> Result<[G; OUT_473], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[480].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[480].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __ret: [G; OUT_473] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[473].weight(); } record.function_queries[473].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_473] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[473].weight(); } record.function_queries[473].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42376,38 +42850,39 @@ fn aiur_fn_474( unconstrained: bool, ) -> Result<[G; OUT_474], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[480].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[480].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[480].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[480].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; let __ret: [G; OUT_474] = [__v_12, __v_13, __v_14]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[474].weight(); } record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_474] = [__v_8, __v_0, __v_1]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[474].weight(); } record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42415,7 +42890,7 @@ fn aiur_fn_474( _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_474] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[474].weight(); } record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42432,30 +42907,31 @@ fn aiur_fn_475( unconstrained: bool, ) -> Result<[G; OUT_475], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[479].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[479].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[479].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_479] = unsafe { *(record.function_queries[479].output_at(__i).as_ptr() as *const [G; OUT_479]) }; __ret }, _ => aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __ret: [G; OUT_475] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[475].weight(); } record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -42468,35 +42944,35 @@ fn aiur_fn_475( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[478].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[478].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_478] = unsafe { *(record.function_queries[478].output_at(__i).as_ptr() as *const [G; OUT_478]) }; __ret }, _ => aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_475] = [__v_21, __v_1, __v_2]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[475].weight(); } record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[483].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __ret: [G; OUT_475] = [__v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[475].weight(); } record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_475] = [__v_23, __v_1, __v_2]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[475].weight(); } record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42517,30 +42993,31 @@ fn aiur_fn_476( unconstrained: bool, ) -> Result<[G; OUT_476], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[479].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[479].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[479].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_479] = unsafe { *(record.function_queries[479].output_at(__i).as_ptr() as *const [G; OUT_479]) }; __ret }, _ => aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; let __ret: [G; OUT_476] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[476].weight(); } record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -42553,35 +43030,35 @@ fn aiur_fn_476( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[478].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[478].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_478] = unsafe { *(record.function_queries[478].output_at(__i).as_ptr() as *const [G; OUT_478]) }; __ret }, _ => aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); let __ret: [G; OUT_476] = [__v_21, __v_1, __v_2]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[476].weight(); } record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[483].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; let __ret: [G; OUT_476] = [__v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[476].weight(); } record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_476] = [__v_23, __v_1, __v_2]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[476].weight(); } record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42602,14 +43079,15 @@ fn aiur_fn_477( unconstrained: bool, ) -> Result<[G; OUT_477], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[479].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[479].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[479].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_479] = unsafe { *(record.function_queries[479].output_at(__i).as_ptr() as *const [G; OUT_479]) }; __ret }, _ => aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[479].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[479].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[479].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_479] = unsafe { *(record.function_queries[479].output_at(__i).as_ptr() as *const [G; OUT_479]) }; __ret }, _ => aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -42618,23 +43096,23 @@ fn aiur_fn_477( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[477].weight(); } record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[477].weight(); } record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42644,18 +43122,18 @@ fn aiur_fn_477( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[477].weight(); } record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_477] = [__v_8, __v_0, __v_1]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[477].weight(); } record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42674,6 +43152,7 @@ fn aiur_fn_478( unconstrained: bool, ) -> Result<[G; OUT_478], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -42690,19 +43169,19 @@ fn aiur_fn_478( 1u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_478] = [__v_12]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[478].weight(); } record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_478] = [__v_12]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[478].weight(); } record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_478] = [__v_12]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[478].weight(); } record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42719,48 +43198,49 @@ fn aiur_fn_479( unconstrained: bool, ) -> Result<[G; OUT_479], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[480].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[480].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(8); - let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[479].weight(); } record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_17, __v_0]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[479].weight(); } record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42768,7 +43248,7 @@ fn aiur_fn_479( _ => { let __v_15: G = G::from_u64(1); let __ret: [G; OUT_479] = [__v_15, __v_8]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[479].weight(); } record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42776,7 +43256,7 @@ fn aiur_fn_479( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_479] = [__v_8, __v_0]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[479].weight(); } record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42793,20 +43273,21 @@ fn aiur_fn_480( unconstrained: bool, ) -> Result<[G; OUT_480], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -42821,29 +43302,29 @@ fn aiur_fn_480( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_480] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[480].weight(); } record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_480] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[480].weight(); } record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); let __ret: [G; OUT_480] = [__v_20, __v_0]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[480].weight(); } record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42851,7 +43332,7 @@ fn aiur_fn_480( _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_480] = [__v_7, __v_0]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[480].weight(); } record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42868,20 +43349,21 @@ fn aiur_fn_481( unconstrained: bool, ) -> Result<[G; OUT_481], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[482].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[482].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_4.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_481] = [__v_7]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[481].weight(); } record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -42889,13 +43371,13 @@ fn aiur_fn_481( 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_481] = [__v_7]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[481].weight(); } record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -42908,9 +43390,9 @@ fn aiur_fn_481( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; let __v_22: G = __loaded[1]; let __v_23: G = __loaded[2]; @@ -42923,27 +43405,27 @@ fn aiur_fn_481( let __v_30: G = __loaded[9]; let __v_31: G = __loaded[10]; let __v_32: G = __loaded[11]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[483].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[483].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; match __v_33.as_canonical_u64() { 1u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_481] = [__v_37]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[481].weight(); } record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_481] = [__v_37]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[481].weight(); } record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42951,16 +43433,16 @@ fn aiur_fn_481( 0u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_481] = [__v_37]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[481].weight(); } record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); let __ret: [G; OUT_481] = [__v_37]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[481].weight(); } record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -42986,11 +43468,12 @@ fn aiur_fn_482( unconstrained: bool, ) -> Result<[G; OUT_482], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -42999,7 +43482,7 @@ fn aiur_fn_482( 2u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_482] = [__v_4, __v_7]; - if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[482].weight(); } record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -43035,10 +43518,10 @@ fn aiur_fn_482( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_40: G = G::from_u64(0); let __ret: [G; OUT_482] = [__v_39, __v_40]; - if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[482].weight(); } record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -43055,6 +43538,7 @@ fn aiur_fn_483( unconstrained: bool, ) -> Result<[G; OUT_483], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -43071,43 +43555,43 @@ fn aiur_fn_483( let __v_13: G = inp[13]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[480].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[480].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_483] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[483].weight(); } record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_483] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[483].weight(); } record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[480].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[480].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_483] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[483].weight(); } record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); let __ret: [G; OUT_483] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[483].weight(); } record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -43115,7 +43599,7 @@ fn aiur_fn_483( _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_483] = [__v_14, __v_0]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[483].weight(); } record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -43132,26 +43616,27 @@ fn aiur_fn_484( unconstrained: bool, ) -> Result<[G; OUT_484], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[486].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_484] = [__v_6]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[484].weight(); } record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[485].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[485].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[485].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_485] = unsafe { *(record.function_queries[485].output_at(__i).as_ptr() as *const [G; OUT_485]) }; __ret }, _ => aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_484] = [__v_3]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[484].weight(); } record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -43168,42 +43653,43 @@ fn aiur_fn_485( unconstrained: bool, ) -> Result<[G; OUT_485], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[341].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[486].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_485] = [__v_8]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[485].weight(); } record.function_queries[485].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_2 - __v_6); - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[486].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_485] = [__v_14]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[485].weight(); } record.function_queries[485].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -43220,43 +43706,44 @@ fn aiur_fn_486( unconstrained: bool, ) -> Result<[G; OUT_486], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_486] = [__v_10]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_486] = [__v_12]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -43269,91 +43756,91 @@ fn aiur_fn_486( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[427].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[427].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[427].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_427] = unsafe { *(record.function_queries[427].output_at(__i).as_ptr() as *const [G; OUT_427]) }; __ret }, _ => aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[428].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_20 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_486] = [__v_22]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[487].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_486] = [__v_12]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(5); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_486] = [__v_12]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[328].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[328].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[328].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_486] = [__v_13]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[496].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_486] = [__v_9]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[488].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[488].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_488] = unsafe { *(record.function_queries[488].output_at(__i).as_ptr() as *const [G; OUT_488]) }; __ret }, _ => aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_486] = [__v_6]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[494].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[494].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[494].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => aiur_fn_494(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_486] = [__v_6]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -43373,43 +43860,44 @@ fn aiur_fn_487( unconstrained: bool, ) -> Result<[G; OUT_487], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_487] = [__v_0]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[487].weight(); } record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_487] = [__v_9]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[487].weight(); } record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() { 0u64 => { @@ -43417,24 +43905,24 @@ fn aiur_fn_487( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_0 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[496].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[487].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_487] = [__v_15]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[487].weight(); } record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() { 0u64 => { @@ -43442,32 +43930,32 @@ fn aiur_fn_487( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_1 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_12, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[496].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[487].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_487] = [__v_23]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[487].weight(); } record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -43494,33 +43982,34 @@ fn aiur_fn_488( unconstrained: bool, ) -> Result<[G; OUT_488], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; let __hit = record.function_queries[378].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[378].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[378].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_378] = unsafe { *(record.function_queries[378].output_at(__i).as_ptr() as *const [G; OUT_378]) }; __ret }, _ => aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_488] = [__v_8]; - if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[488].weight(); } record.function_queries[488].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[214].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_488] = [__v_8]; - if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[488].weight(); } record.function_queries[488].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -43540,15 +44029,16 @@ fn aiur_fn_489( unconstrained: bool, ) -> Result<[G; OUT_489], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[490].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[490].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_490] = unsafe { *(record.function_queries[490].output_at(__i).as_ptr() as *const [G; OUT_490]) }; __ret }, _ => aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -43557,11 +44047,11 @@ fn aiur_fn_489( 1u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_7, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_489] = [__v_13]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[489].weight(); } record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -43581,21 +44071,22 @@ fn aiur_fn_490( unconstrained: bool, ) -> Result<[G; OUT_490], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_490] = [__v_3]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[490].weight(); } record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -43603,18 +44094,18 @@ fn aiur_fn_490( match __v_4.as_canonical_u64() { 5u64 => { let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[490].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[490].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_490] = unsafe { *(record.function_queries[490].output_at(__i).as_ptr() as *const [G; OUT_490]) }; __ret }, _ => aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_490] = [__v_12]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[490].weight(); } record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_490] = [__v_3]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[490].weight(); } record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -43633,29 +44124,30 @@ fn aiur_fn_491( unconstrained: bool, ) -> Result<[G; OUT_491], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_491] = []; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[491].weight(); } record.function_queries[491].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("projection on a Prop structure: field is not a Prop".to_string()) }); } let __ret: [G; OUT_491] = []; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[491].weight(); } record.function_queries[491].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -43672,6 +44164,7 @@ fn aiur_fn_492( unconstrained: bool, ) -> Result<[G; OUT_492], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -43679,32 +44172,32 @@ fn aiur_fn_492( match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_492] = []; - if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[492].weight(); } record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_492] = []; - if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[492].weight(); } record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("projection on a Prop structure: later fields depend on a data field".to_string()) }); } let __ret: [G; OUT_492] = []; - if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[492].weight(); } record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -43723,6 +44216,7 @@ fn aiur_fn_493( unconstrained: bool, ) -> Result<[G; OUT_493], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -43730,7 +44224,7 @@ fn aiur_fn_493( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -43740,24 +44234,24 @@ fn aiur_fn_493( let __v_11: G = (__v_1 - __v_2); match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[491].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[491].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[491].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_491] = unsafe { *(record.function_queries[491].output_at(__i).as_ptr() as *const [G; OUT_491]) }; __ret }, _ => aiur_fn_491(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_493] = [__v_8]; - if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[493].weight(); } record.function_queries[493].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_492(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[492].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_12: G = G::from_u64(8); - let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 + __v_16); - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[493].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[493].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_493] = unsafe { *(record.function_queries[493].output_at(__i).as_ptr() as *const [G; OUT_493]) }; __ret }, _ => aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_493] = [__v_18]; - if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[493].weight(); } record.function_queries[493].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -43779,27 +44273,28 @@ fn aiur_fn_494( unconstrained: bool, ) -> Result<[G; OUT_494], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -43818,9 +44313,9 @@ fn aiur_fn_494( match __v_13.as_canonical_u64() { 5u64 => { let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; let __v_28: G = __loaded[1]; let __v_29: G = __loaded[2]; @@ -43839,18 +44334,18 @@ fn aiur_fn_494( } match __v_27.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_29, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[432].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_16 + __v_17); - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[489].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[489].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[493].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[493].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_493] = unsafe { *(record.function_queries[493].output_at(__i).as_ptr() as *const [G; OUT_493]) }; __ret }, _ => aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __ret: [G; OUT_494] = [__v_45]; - if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[494].weight(); } record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -43880,13 +44375,14 @@ fn aiur_fn_495( unconstrained: bool, ) -> Result<[G; OUT_495], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -43894,7 +44390,7 @@ fn aiur_fn_495( match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_495] = [__v_5]; - if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[495].weight(); } record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -43914,19 +44410,20 @@ fn aiur_fn_496( unconstrained: bool, ) -> Result<[G; OUT_496], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("inferred type is not def-eq to the expected type".to_string()) }); } let __ret: [G; OUT_496] = []; - if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[496].weight(); } record.function_queries[496].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -43941,6 +44438,7 @@ fn aiur_fn_497( unconstrained: bool, ) -> Result<[G; OUT_497], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(69); let __v_1: G = G::from_u64(96); let __v_2: G = G::from_u64(197); @@ -43973,9 +44471,9 @@ fn aiur_fn_497( let __v_29: G = G::from_u64(87); let __v_30: G = G::from_u64(47); let __v_31: G = G::from_u64(219); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_497] = [__v_32]; - if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[497].weight(); } record.function_queries[497].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -43990,6 +44488,7 @@ fn aiur_fn_498( unconstrained: bool, ) -> Result<[G; OUT_498], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(163); let __v_1: G = G::from_u64(245); let __v_2: G = G::from_u64(168); @@ -44022,9 +44521,9 @@ fn aiur_fn_498( let __v_29: G = G::from_u64(254); let __v_30: G = G::from_u64(51); let __v_31: G = G::from_u64(118); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_498] = [__v_32]; - if let Some(result) = record.function_queries[498].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[498].weight(); } record.function_queries[498].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44039,6 +44538,7 @@ fn aiur_fn_499( unconstrained: bool, ) -> Result<[G; OUT_499], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(46); let __v_1: G = G::from_u64(163); let __v_2: G = G::from_u64(101); @@ -44071,9 +44571,9 @@ fn aiur_fn_499( let __v_29: G = G::from_u64(157); let __v_30: G = G::from_u64(126); let __v_31: G = G::from_u64(143); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_499] = [__v_32]; - if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[499].weight(); } record.function_queries[499].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44088,6 +44588,7 @@ fn aiur_fn_500( unconstrained: bool, ) -> Result<[G; OUT_500], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(15); let __v_1: G = G::from_u64(158); let __v_2: G = G::from_u64(232); @@ -44120,9 +44621,9 @@ fn aiur_fn_500( let __v_29: G = G::from_u64(169); let __v_30: G = G::from_u64(131); let __v_31: G = G::from_u64(129); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_500] = [__v_32]; - if let Some(result) = record.function_queries[500].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[500].weight(); } record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44137,6 +44638,7 @@ fn aiur_fn_501( unconstrained: bool, ) -> Result<[G; OUT_501], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(4); let __v_1: G = G::from_u64(113); let __v_2: G = G::from_u64(228); @@ -44169,9 +44671,9 @@ fn aiur_fn_501( let __v_29: G = G::from_u64(188); let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(149); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_501] = [__v_32]; - if let Some(result) = record.function_queries[501].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[501].weight(); } record.function_queries[501].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44186,6 +44688,7 @@ fn aiur_fn_502( unconstrained: bool, ) -> Result<[G; OUT_502], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(4); let __v_1: G = G::from_u64(42); let __v_2: G = G::from_u64(154); @@ -44218,9 +44721,9 @@ fn aiur_fn_502( let __v_29: G = G::from_u64(213); let __v_30: G = G::from_u64(142); let __v_31: G = G::from_u64(179); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_502] = [__v_32]; - if let Some(result) = record.function_queries[502].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[502].weight(); } record.function_queries[502].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44235,6 +44738,7 @@ fn aiur_fn_503( unconstrained: bool, ) -> Result<[G; OUT_503], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(125); let __v_1: G = G::from_u64(175); let __v_2: G = G::from_u64(170); @@ -44267,9 +44771,9 @@ fn aiur_fn_503( let __v_29: G = G::from_u64(166); let __v_30: G = G::from_u64(175); let __v_31: G = G::from_u64(221); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_503] = [__v_32]; - if let Some(result) = record.function_queries[503].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[503].weight(); } record.function_queries[503].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44284,6 +44788,7 @@ fn aiur_fn_504( unconstrained: bool, ) -> Result<[G; OUT_504], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(248); let __v_1: G = G::from_u64(49); let __v_2: G = G::from_u64(57); @@ -44316,9 +44821,9 @@ fn aiur_fn_504( let __v_29: G = G::from_u64(178); let __v_30: G = G::from_u64(58); let __v_31: G = G::from_u64(16); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_504] = [__v_32]; - if let Some(result) = record.function_queries[504].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[504].weight(); } record.function_queries[504].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44333,6 +44838,7 @@ fn aiur_fn_505( unconstrained: bool, ) -> Result<[G; OUT_505], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(122); let __v_1: G = G::from_u64(236); let __v_2: G = G::from_u64(194); @@ -44365,9 +44871,9 @@ fn aiur_fn_505( let __v_29: G = G::from_u64(183); let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(194); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_505] = [__v_32]; - if let Some(result) = record.function_queries[505].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[505].weight(); } record.function_queries[505].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44382,6 +44888,7 @@ fn aiur_fn_506( unconstrained: bool, ) -> Result<[G; OUT_506], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(230); let __v_1: G = G::from_u64(235); let __v_2: G = G::from_u64(163); @@ -44414,9 +44921,9 @@ fn aiur_fn_506( let __v_29: G = G::from_u64(201); let __v_30: G = G::from_u64(160); let __v_31: G = G::from_u64(164); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_506] = [__v_32]; - if let Some(result) = record.function_queries[506].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[506].weight(); } record.function_queries[506].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44431,6 +44938,7 @@ fn aiur_fn_507( unconstrained: bool, ) -> Result<[G; OUT_507], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(108); let __v_1: G = G::from_u64(155); let __v_2: G = G::from_u64(214); @@ -44463,9 +44971,9 @@ fn aiur_fn_507( let __v_29: G = G::from_u64(167); let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(206); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_507] = [__v_32]; - if let Some(result) = record.function_queries[507].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[507].weight(); } record.function_queries[507].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44480,6 +44988,7 @@ fn aiur_fn_508( unconstrained: bool, ) -> Result<[G; OUT_508], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(15); let __v_1: G = G::from_u64(83); let __v_2: G = G::from_u64(188); @@ -44512,9 +45021,9 @@ fn aiur_fn_508( let __v_29: G = G::from_u64(207); let __v_30: G = G::from_u64(244); let __v_31: G = G::from_u64(248); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_508] = [__v_32]; - if let Some(result) = record.function_queries[508].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[508].weight(); } record.function_queries[508].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44529,6 +45038,7 @@ fn aiur_fn_509( unconstrained: bool, ) -> Result<[G; OUT_509], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(14); let __v_1: G = G::from_u64(95); let __v_2: G = G::from_u64(112); @@ -44561,9 +45071,9 @@ fn aiur_fn_509( let __v_29: G = G::from_u64(66); let __v_30: G = G::from_u64(63); let __v_31: G = G::from_u64(174); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_509] = [__v_32]; - if let Some(result) = record.function_queries[509].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[509].weight(); } record.function_queries[509].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44578,6 +45088,7 @@ fn aiur_fn_510( unconstrained: bool, ) -> Result<[G; OUT_510], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(206); let __v_1: G = G::from_u64(19); let __v_2: G = G::from_u64(124); @@ -44610,9 +45121,9 @@ fn aiur_fn_510( let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(16); let __v_31: G = G::from_u64(140); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_510] = [__v_32]; - if let Some(result) = record.function_queries[510].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[510].weight(); } record.function_queries[510].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44627,82 +45138,83 @@ fn aiur_fn_511( unconstrained: bool, ) -> Result<[G; OUT_511], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; let __hit = record.function_queries[497].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[497].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_511] = [__v_3]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[498].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_511] = [__v_5]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[499].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_511] = [__v_7]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[509].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_511] = [__v_9]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; let __hit = record.function_queries[508].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[508].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[508].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_508] = unsafe { *(record.function_queries[508].output_at(__i).as_ptr() as *const [G; OUT_508]) }; __ret }, _ => aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_511] = [__v_11]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; let __hit = record.function_queries[510].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[510].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[510].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_510] = unsafe { *(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510]) }; __ret }, _ => aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __ret: [G; OUT_511] = [__v_13]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_511] = [__v_13]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -44729,46 +45241,47 @@ fn aiur_fn_512( unconstrained: bool, ) -> Result<[G; OUT_512], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[509].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_512] = [__v_3]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[512].weight(); } record.function_queries[512].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; let __hit = record.function_queries[508].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[508].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[508].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_508] = unsafe { *(record.function_queries[508].output_at(__i).as_ptr() as *const [G; OUT_508]) }; __ret }, _ => aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_512] = [__v_5]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[512].weight(); } record.function_queries[512].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; let __hit = record.function_queries[510].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[510].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[510].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_510] = unsafe { *(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510]) }; __ret }, _ => aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_512] = [__v_7]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[512].weight(); } record.function_queries[512].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_512] = [__v_7]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[512].weight(); } record.function_queries[512].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -44789,28 +45302,29 @@ fn aiur_fn_513( unconstrained: bool, ) -> Result<[G; OUT_513], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[147].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_10 + __v_12); match __v_13.as_canonical_u64() { @@ -44819,13 +45333,13 @@ fn aiur_fn_513( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_513] = [__v_14, __v_15, __v_18]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[513].weight(); } record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -44836,7 +45350,7 @@ fn aiur_fn_513( 0u64 => { let __v_18: G = G::from_u64(1); let __ret: [G; OUT_513] = [__v_18, __v_12, __v_16]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[513].weight(); } record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -44844,9 +45358,9 @@ fn aiur_fn_513( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_513] = [__v_18, __v_19, __v_22]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[513].weight(); } record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -44856,9 +45370,9 @@ fn aiur_fn_513( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_513] = [__v_18, __v_19, __v_22]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[513].weight(); } record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -44870,9 +45384,9 @@ fn aiur_fn_513( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_513] = [__v_9, __v_10, __v_13]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[513].weight(); } record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -44882,9 +45396,9 @@ fn aiur_fn_513( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_513] = [__v_5, __v_6, __v_9]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[513].weight(); } record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -44901,16 +45415,17 @@ fn aiur_fn_514( unconstrained: bool, ) -> Result<[G; OUT_514], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, _ => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[147].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, @@ -44920,18 +45435,18 @@ fn aiur_fn_514( let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_3, __v_2, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_3, __v_2, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_9: G = G::from_u64(7); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_1, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_1, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_514] = [__v_15]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[514].weight(); } record.function_queries[514].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -44946,11 +45461,12 @@ fn aiur_fn_515( unconstrained: bool, ) -> Result<[G; OUT_515], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -44960,25 +45476,25 @@ fn aiur_fn_515( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_515] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[515].weight(); } record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[513].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[513].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[513].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_513] = unsafe { *(record.function_queries[513].output_at(__i).as_ptr() as *const [G; OUT_513]) }; __ret }, _ => aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[513].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[513].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[513].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_513] = unsafe { *(record.function_queries[513].output_at(__i).as_ptr() as *const [G; OUT_513]) }; __ret }, _ => aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -44988,27 +45504,27 @@ fn aiur_fn_515( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_515] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[515].weight(); } record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[516].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[516].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[516].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_516] = unsafe { *(record.function_queries[516].output_at(__i).as_ptr() as *const [G; OUT_516]) }; __ret }, _ => aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_515] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[515].weight(); } record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[516].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[516].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[516].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_516] = unsafe { *(record.function_queries[516].output_at(__i).as_ptr() as *const [G; OUT_516]) }; __ret }, _ => aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_515] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[515].weight(); } record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45027,49 +45543,50 @@ fn aiur_fn_516( unconstrained: bool, ) -> Result<[G; OUT_516], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[513].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[513].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[513].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_513] = unsafe { *(record.function_queries[513].output_at(__i).as_ptr() as *const [G; OUT_513]) }; __ret }, _ => aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[513].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[513].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[513].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_513] = unsafe { *(record.function_queries[513].output_at(__i).as_ptr() as *const [G; OUT_513]) }; __ret }, _ => aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[514].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[514].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_22: G = G::from_u64(3); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_24, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_516] = [__v_27, __v_28]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[516].weight(); } record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -45077,9 +45594,9 @@ fn aiur_fn_516( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_516] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[516].weight(); } record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45089,9 +45606,9 @@ fn aiur_fn_516( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_516] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[516].weight(); } record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45108,11 +45625,12 @@ fn aiur_fn_517( unconstrained: bool, ) -> Result<[G; OUT_517], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45122,51 +45640,51 @@ fn aiur_fn_517( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_517] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[517].weight(); } record.function_queries[517].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[512].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[512].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[512].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_512] = unsafe { *(record.function_queries[512].output_at(__i).as_ptr() as *const [G; OUT_512]) }; __ret }, _ => aiur_fn_512(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_515(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[515].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[515].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[515].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_515] = unsafe { *(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515]) }; __ret }, _ => aiur_fn_515(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_517] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[517].weight(); } record.function_queries[517].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; let __hit = record.function_queries[497].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[497].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[498].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[499].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_518(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[518].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[518].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[518].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_518] = unsafe { *(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518]) }; __ret }, _ => aiur_fn_518(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_517] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[517].weight(); } record.function_queries[517].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[519].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[519].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[519].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_519] = unsafe { *(record.function_queries[519].output_at(__i).as_ptr() as *const [G; OUT_519]) }; __ret }, _ => aiur_fn_519(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_517] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[517].weight(); } record.function_queries[517].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45187,18 +45705,19 @@ fn aiur_fn_518( unconstrained: bool, ) -> Result<[G; OUT_518], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -45207,35 +45726,35 @@ fn aiur_fn_518( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_518] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[518].weight(); } record.function_queries[518].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; let __hit = record.function_queries[497].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[497].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_21, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_518] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[518].weight(); } record.function_queries[518].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -45255,6 +45774,7 @@ fn aiur_fn_519( unconstrained: bool, ) -> Result<[G; OUT_519], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -45262,16 +45782,16 @@ fn aiur_fn_519( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_7, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -45280,13 +45800,13 @@ fn aiur_fn_519( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_519] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[519].weight(); } record.function_queries[519].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { @@ -45295,31 +45815,31 @@ fn aiur_fn_519( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_519] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[519].weight(); } record.function_queries[519].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, _ => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_13, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[334].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[520].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[520].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[520].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_520] = unsafe { *(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520]) }; __ret }, _ => aiur_fn_520(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_519] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[519].weight(); } record.function_queries[519].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -45344,6 +45864,7 @@ fn aiur_fn_520( unconstrained: bool, ) -> Result<[G; OUT_520], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -45362,44 +45883,44 @@ fn aiur_fn_520( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_520] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[520].weight(); } record.function_queries[520].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_23: G = G::from_u64(2); - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; let __hit = record.function_queries[507].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[507].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[507].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_507] = unsafe { *(record.function_queries[507].output_at(__i).as_ptr() as *const [G; OUT_507]) }; __ret }, _ => aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; let __hit = record.function_queries[506].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[506].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[506].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_506] = unsafe { *(record.function_queries[506].output_at(__i).as_ptr() as *const [G; OUT_506]) }; __ret }, _ => aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[172].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; break '__mc_0 [__v_34]; }, _ => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; break '__mc_0 [__v_34]; }, @@ -45409,25 +45930,25 @@ fn aiur_fn_520( let __v_35: G = G::from_u64(2); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 4] = [__v_35, __v_34, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 4] = [__v_35, __v_34, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_41, __v_26, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_41, __v_26, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_44: G = G::from_u64(3); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_43, __v_40, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_43, __v_40, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_0.as_canonical_u64() { 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; let __hit = record.function_queries[502].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[502].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[502].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_502] = unsafe { *(record.function_queries[502].output_at(__i).as_ptr() as *const [G; OUT_502]) }; __ret }, _ => aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; let __hit = record.function_queries[503].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[503].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[503].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_503] = unsafe { *(record.function_queries[503].output_at(__i).as_ptr() as *const [G; OUT_503]) }; __ret }, _ => aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -45436,12 +45957,12 @@ fn aiur_fn_520( _ => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; let __hit = record.function_queries[504].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[504].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_504] = unsafe { *(record.function_queries[504].output_at(__i).as_ptr() as *const [G; OUT_504]) }; __ret }, _ => aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; let __hit = record.function_queries[505].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[505].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_505] = unsafe { *(record.function_queries[505].output_at(__i).as_ptr() as *const [G; OUT_505]) }; __ret }, _ => aiur_fn_505(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -45453,23 +45974,23 @@ fn aiur_fn_520( let __v_48: G = G::from_u64(2); let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 4] = [__v_48, __v_47, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 4] = [__v_48, __v_47, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_54: G = G::from_u64(3); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_3, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_3, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_57: G = G::from_u64(3); let __v_58: G = G::from_u64(0); - let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_4, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_4, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); - let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_523(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[523].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[523].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[523].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_523] = unsafe { *(record.function_queries[523].output_at(__i).as_ptr() as *const [G; OUT_523]) }; __ret }, _ => aiur_fn_523(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __ret: [G; OUT_520] = [__v_63, __v_64]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[520].weight(); } record.function_queries[520].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45486,10 +46007,11 @@ fn aiur_fn_521( unconstrained: bool, ) -> Result<[G; OUT_521], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(2); let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45499,19 +46021,19 @@ fn aiur_fn_521( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_521] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -45520,7 +46042,7 @@ fn aiur_fn_521( 7u64 => { match __v_11.as_canonical_u64() { 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -45529,7 +46051,7 @@ fn aiur_fn_521( 7u64 => { match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_12, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[335].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[335].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -45537,17 +46059,17 @@ fn aiur_fn_521( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_521] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_522(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[522].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[522].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[522].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_522] = unsafe { *(record.function_queries[522].output_at(__i).as_ptr() as *const [G; OUT_522]) }; __ret }, _ => aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_521] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45557,9 +46079,9 @@ fn aiur_fn_521( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_521] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45569,9 +46091,9 @@ fn aiur_fn_521( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_521] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45581,9 +46103,9 @@ fn aiur_fn_521( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_521] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45593,9 +46115,9 @@ fn aiur_fn_521( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_521] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45614,6 +46136,7 @@ fn aiur_fn_522( unconstrained: bool, ) -> Result<[G; OUT_522], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -45621,56 +46144,56 @@ fn aiur_fn_522( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_4, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_4, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; let __hit = record.function_queries[507].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[507].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[507].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_507] = unsafe { *(record.function_queries[507].output_at(__i).as_ptr() as *const [G; OUT_507]) }; __ret }, _ => aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[214].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_24: G = G::from_u64(0); - let __v_25: G = { let __values: [G; 4] = [__v_19, __v_20, __v_23, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 4] = [__v_19, __v_20, __v_23, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_0, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_0, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 4] = [__v_30, __v_18, __v_25, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_30, __v_18, __v_25, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_33: G = G::from_u64(3); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_29, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_29, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_36: G = G::from_u64(2); let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_42: G = G::from_u64(2); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_41, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_44, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_45, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = { let __a_val = __v_49.as_canonical_u64(); let __b_val = __v_50.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45680,37 +46203,37 @@ fn aiur_fn_522( let __v_53: G = G::from_u64(0); let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_522] = [__v_52, __v_56]; - if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[522].weight(); } record.function_queries[522].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_48, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(2); - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[500].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); - let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_59: G = G::from_u64(0); - let __v_60: G = { let __values: [G; 4] = [__v_54, __v_55, __v_58, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_60: G = { let __values: [G; 4] = [__v_54, __v_55, __v_58, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_61: G = G::from_u64(3); let __v_62: G = G::from_u64(0); - let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_53, __v_62]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_53, __v_62]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_64: G = G::from_u64(3); let __v_65: G = G::from_u64(0); - let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_67: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_66, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __ret: [G; OUT_522] = [__v_69, __v_70]; - if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[522].weight(); } record.function_queries[522].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45727,6 +46250,7 @@ fn aiur_fn_523( unconstrained: bool, ) -> Result<[G; OUT_523], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -45735,12 +46259,12 @@ fn aiur_fn_523( let __v_5: G = inp[5]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[500].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, _ => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[501].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, @@ -45749,20 +46273,20 @@ fn aiur_fn_523( let __v_6: G = __mc_out___mc_0[0]; let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_12, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = { let __a_val = __v_17.as_canonical_u64(); let __b_val = __v_18.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -45772,35 +46296,35 @@ fn aiur_fn_523( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_523] = [__v_20, __v_24]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[523].weight(); } record.function_queries[523].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_16, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_28: G = G::from_u64(3); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_21, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_21, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_34: G = G::from_u64(2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_4, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_33, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_523] = [__v_36, __v_37]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[523].weight(); } record.function_queries[523].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45817,6 +46341,7 @@ fn aiur_fn_524( unconstrained: bool, ) -> Result<[G; OUT_524], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = (__v_0 - __v_1); @@ -45824,7 +46349,7 @@ fn aiur_fn_524( 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_524] = [__v_3]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[524].weight(); } record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -45833,13 +46358,13 @@ fn aiur_fn_524( 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_524] = [__v_4]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[524].weight(); } record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); let __ret: [G; OUT_524] = [__v_4]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[524].weight(); } record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -45861,17 +46386,18 @@ fn aiur_fn_525( unconstrained: bool, ) -> Result<[G; OUT_525], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_525] = [__v_1]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[525].weight(); } record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_525] = [__v_0]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[525].weight(); } record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45888,10 +46414,11 @@ fn aiur_fn_526( unconstrained: bool, ) -> Result<[G; OUT_526], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(1); let __ret: [G; OUT_526] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[526].weight(); } record.function_queries[526].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -45906,10 +46433,11 @@ fn aiur_fn_527( unconstrained: bool, ) -> Result<[G; OUT_527], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(1); let __v_1: G = G::from_u64(1); let __ret: [G; OUT_527] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[527].weight(); } record.function_queries[527].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -45924,10 +46452,11 @@ fn aiur_fn_528( unconstrained: bool, ) -> Result<[G; OUT_528], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(2); let __v_1: G = G::from_u64(1); let __ret: [G; OUT_528] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[528].weight(); } record.function_queries[528].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -45942,6 +46471,7 @@ fn aiur_fn_529( unconstrained: bool, ) -> Result<[G; OUT_529], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -45950,12 +46480,12 @@ fn aiur_fn_529( 1u64 => { let __v_4: G = (__v_1 * __v_3); let __ret: [G; OUT_529] = [__v_2, __v_4]; - if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[529].weight(); } record.function_queries[529].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_529] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[529].weight(); } record.function_queries[529].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -45972,10 +46502,11 @@ fn aiur_fn_530( unconstrained: bool, ) -> Result<[G; OUT_530], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __ret: [G; OUT_530] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[530].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[530].weight(); } record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -45990,9 +46521,10 @@ fn aiur_fn_531( unconstrained: bool, ) -> Result<[G; OUT_531], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -46025,7 +46557,7 @@ fn aiur_fn_531( let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -46058,38 +46590,38 @@ fn aiur_fn_531( let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_72, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_71, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_70, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_69, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_68, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_67, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_66, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; let __ret: [G; OUT_531] = [__v_80]; - if let Some(result) = record.function_queries[531].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[531].weight(); } record.function_queries[531].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -46104,6 +46636,7 @@ fn aiur_fn_532( unconstrained: bool, ) -> Result<[G; OUT_532], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -46130,10 +46663,10 @@ fn aiur_fn_532( let __v_23: G = (__v_22 + __v_7); let __v_24: G = (__v_20 + __v_23); let __v_25: G = (__v_18 + __v_24); - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_16, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_532] = [__v_26]; - if let Some(result) = record.function_queries[532].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[532].weight(); } record.function_queries[532].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -46148,9 +46681,10 @@ fn aiur_fn_533( unconstrained: bool, ) -> Result<[G; OUT_533], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -46159,25 +46693,25 @@ fn aiur_fn_533( 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_533] = [__v_6]; - if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[533].weight(); } record.function_queries[533].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_7 + __v_4); let __ret: [G; OUT_533] = [__v_8]; - if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[533].weight(); } record.function_queries[533].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[533].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_533] = [__v_7]; - if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[533].weight(); } record.function_queries[533].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -46199,44 +46733,45 @@ fn aiur_fn_534( unconstrained: bool, ) -> Result<[G; OUT_534], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __ret: [G; OUT_534] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[534].weight(); } record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[533].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[533].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[531].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_534] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[534].weight(); } record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_534] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[534].weight(); } record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -46244,19 +46779,19 @@ fn aiur_fn_534( _ => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_534] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[534].weight(); } record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __ret: [G; OUT_534] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[534].weight(); } record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -46277,15 +46812,16 @@ fn aiur_fn_535( unconstrained: bool, ) -> Result<[G; OUT_535], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -46293,19 +46829,19 @@ fn aiur_fn_535( 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -46313,26 +46849,26 @@ fn aiur_fn_535( 0u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 2u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -46340,36 +46876,36 @@ fn aiur_fn_535( 0u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_535] = [__v_10]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -46377,36 +46913,36 @@ fn aiur_fn_535( 0u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_535] = [__v_10]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -46415,22 +46951,22 @@ fn aiur_fn_535( } }, 4u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -46452,15 +46988,16 @@ fn aiur_fn_536( unconstrained: bool, ) -> Result<[G; OUT_536], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -46468,19 +47005,19 @@ fn aiur_fn_536( 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_536] = [__v_8]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[536].weight(); } record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_536] = [__v_8]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[536].weight(); } record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -46488,18 +47025,18 @@ fn aiur_fn_536( 1u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_536] = [__v_8]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[536].weight(); } record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[536].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[536].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_536] = unsafe { *(record.function_queries[536].output_at(__i).as_ptr() as *const [G; OUT_536]) }; __ret }, _ => aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_536] = [__v_10]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[536].weight(); } record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -46524,6 +47061,7 @@ fn aiur_fn_537( unconstrained: bool, ) -> Result<[G; OUT_537], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -46532,16 +47070,16 @@ fn aiur_fn_537( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[538].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_537] = [__v_4]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[537].weight(); } record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_537] = [__v_4]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[537].weight(); } record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -46554,14 +47092,14 @@ fn aiur_fn_537( 0u64 => { let __v_4: G = G::from_u64(2); let __ret: [G; OUT_537] = [__v_4]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[537].weight(); } record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[541].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[541].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_541] = unsafe { *(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541]) }; __ret }, _ => aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_537] = [__v_4]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[537].weight(); } record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -46586,29 +47124,30 @@ fn aiur_fn_538( unconstrained: bool, ) -> Result<[G; OUT_538], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[763].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[763].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[539].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_538] = [__v_7]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[538].weight(); } record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_538] = [__v_6]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[538].weight(); } record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -46625,9 +47164,10 @@ fn aiur_fn_539( unconstrained: bool, ) -> Result<[G; OUT_539], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -46642,11 +47182,11 @@ fn aiur_fn_539( 1u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_539] = [__v_12]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[539].weight(); } record.function_queries[539].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -46659,14 +47199,14 @@ fn aiur_fn_539( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[539].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[540].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_539] = [__v_24]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[539].weight(); } record.function_queries[539].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -46691,6 +47231,7 @@ fn aiur_fn_540( unconstrained: bool, ) -> Result<[G; OUT_540], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -46707,38 +47248,38 @@ fn aiur_fn_540( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_20, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_19, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_18, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_17, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_16, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_540] = [__v_30]; - if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[540].weight(); } record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -46753,15 +47294,16 @@ fn aiur_fn_541( unconstrained: bool, ) -> Result<[G; OUT_541], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -46769,19 +47311,19 @@ fn aiur_fn_541( 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_541] = [__v_8]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[541].weight(); } record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_541] = [__v_8]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[541].weight(); } record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -46789,18 +47331,18 @@ fn aiur_fn_541( 1u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_541] = [__v_8]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[541].weight(); } record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[541].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[541].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_541] = unsafe { *(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541]) }; __ret }, _ => aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_541] = [__v_10]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[541].weight(); } record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -46825,35 +47367,36 @@ fn aiur_fn_542( unconstrained: bool, ) -> Result<[G; OUT_542], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __ret: [G; OUT_542] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[542].weight(); } record.function_queries[542].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[543].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_542] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[542].weight(); } record.function_queries[542].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -46870,6 +47413,7 @@ fn aiur_fn_543( unconstrained: bool, ) -> Result<[G; OUT_543], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -46883,21 +47427,21 @@ fn aiur_fn_543( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -46905,29 +47449,29 @@ fn aiur_fn_543( 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -46935,43 +47479,43 @@ fn aiur_fn_543( 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[536].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[536].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_536] = unsafe { *(record.function_queries[536].output_at(__i).as_ptr() as *const [G; OUT_536]) }; __ret }, _ => aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[534].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[534].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_534] = unsafe { *(record.function_queries[534].output_at(__i).as_ptr() as *const [G; OUT_534]) }; __ret }, _ => aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -46979,49 +47523,49 @@ fn aiur_fn_543( 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -47029,57 +47573,57 @@ fn aiur_fn_543( 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -47087,65 +47631,65 @@ fn aiur_fn_543( 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -47153,79 +47697,79 @@ fn aiur_fn_543( 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -47233,29 +47777,29 @@ fn aiur_fn_543( 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[537].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[537].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_537] = unsafe { *(record.function_queries[537].output_at(__i).as_ptr() as *const [G; OUT_537]) }; __ret }, _ => aiur_fn_537(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -47263,33 +47807,33 @@ fn aiur_fn_543( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[534].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[534].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_534] = unsafe { *(record.function_queries[534].output_at(__i).as_ptr() as *const [G; OUT_534]) }; __ret }, _ => aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_543] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -47311,6 +47855,7 @@ fn aiur_fn_544( unconstrained: bool, ) -> Result<[G; OUT_544], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -47322,19 +47867,19 @@ fn aiur_fn_544( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_544] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[544].weight(); } record.function_queries[544].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -47353,10 +47898,11 @@ fn aiur_fn_545( unconstrained: bool, ) -> Result<[G; OUT_545], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -47364,7 +47910,7 @@ fn aiur_fn_545( let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -47372,25 +47918,25 @@ fn aiur_fn_545( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_545] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[545].weight(); } record.function_queries[545].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_545] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[545].weight(); } record.function_queries[545].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -47398,25 +47944,25 @@ fn aiur_fn_545( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_545] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[545].weight(); } record.function_queries[545].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[544].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[545].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __ret: [G; OUT_545] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[545].weight(); } record.function_queries[545].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -47441,6 +47987,7 @@ fn aiur_fn_546( unconstrained: bool, ) -> Result<[G; OUT_546], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -47457,49 +48004,49 @@ fn aiur_fn_546( 1u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __v_12: G = G::from_u64(2); let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __v_12: G = G::from_u64(3); let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(4); let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(5); let __ret: [G; OUT_546] = [__v_12]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -47519,6 +48066,7 @@ fn aiur_fn_547( unconstrained: bool, ) -> Result<[G; OUT_547], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -47544,27 +48092,27 @@ fn aiur_fn_547( let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[546].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[546].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[548].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_547] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[547].weight(); } record.function_queries[547].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_547] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[547].weight(); } record.function_queries[547].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -47581,6 +48129,7 @@ fn aiur_fn_548( unconstrained: bool, ) -> Result<[G; OUT_548], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -47610,33 +48159,33 @@ fn aiur_fn_548( 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __ret: [G; OUT_548] = [__v_34, __v_35]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __ret: [G; OUT_548] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -47644,75 +48193,75 @@ fn aiur_fn_548( 5u64 => { match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[549].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __ret: [G; OUT_548] = [__v_51, __v_52]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __ret: [G; OUT_548] = [__v_46, __v_47]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __ret: [G; OUT_548] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -47720,83 +48269,83 @@ fn aiur_fn_548( 7u64 => { match __v_12.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_8, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[545].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __ret: [G; OUT_548] = [__v_59, __v_60]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __ret: [G; OUT_548] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __ret: [G; OUT_548] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -47813,6 +48362,7 @@ fn aiur_fn_549( unconstrained: bool, ) -> Result<[G; OUT_549], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -47823,17 +48373,17 @@ fn aiur_fn_549( let __v_7: G = (__v_4 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_549] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[549].weight(); } record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -47846,9 +48396,9 @@ fn aiur_fn_549( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; @@ -47861,19 +48411,19 @@ fn aiur_fn_549( let __v_31: G = __loaded[9]; let __v_32: G = __loaded[10]; let __v_33: G = __loaded[11]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[550].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[550].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[550].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_550] = unsafe { *(record.function_queries[550].output_at(__i).as_ptr() as *const [G; OUT_550]) }; __ret }, _ => aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = G::from_u64(1); let __v_37: G = (__v_6 + __v_36); - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[549].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __ret: [G; OUT_549] = [__v_40, __v_41]; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[549].weight(); } record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -47890,6 +48440,7 @@ fn aiur_fn_550( unconstrained: bool, ) -> Result<[G; OUT_550], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -47919,73 +48470,73 @@ fn aiur_fn_550( 6u64 => { match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __ret: [G; OUT_550] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[550].weight(); } record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[546].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[546].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_550] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[550].weight(); } record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[546].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[546].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __ret: [G; OUT_550] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[550].weight(); } record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -48002,11 +48553,12 @@ fn aiur_fn_551( unconstrained: bool, ) -> Result<[G; OUT_551], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(4); - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[289].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -48015,7 +48567,7 @@ fn aiur_fn_551( let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[289].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -48027,22 +48579,22 @@ fn aiur_fn_551( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[71].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[71].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_71] = unsafe { *(record.function_queries[71].output_at(__i).as_ptr() as *const [G; OUT_71]) }; __ret }, _ => aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; let __hit = record.function_queries[21].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[21].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_21] = unsafe { *(record.function_queries[21].output_at(__i).as_ptr() as *const [G; OUT_21]) }; __ret }, _ => aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_551] = [__v_34]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[551].weight(); } record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -48057,13 +48609,14 @@ fn aiur_fn_552( unconstrained: bool, ) -> Result<[G; OUT_552], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -48077,7 +48630,7 @@ fn aiur_fn_552( let __v_14: G = __loaded[10]; let __v_15: G = __loaded[11]; let __ret: [G; OUT_552] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[552].weight(); } record.function_queries[552].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -48092,9 +48645,10 @@ fn aiur_fn_553( unconstrained: bool, ) -> Result<[G; OUT_553], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[552].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[552].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[552].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -48110,13 +48664,13 @@ fn aiur_fn_553( match __v_2.as_canonical_u64() { 5u64 => { let __ret: [G; OUT_553] = [__v_7]; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[553].weight(); } record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_553] = [__v_14]; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[553].weight(); } record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -48133,16 +48687,17 @@ fn aiur_fn_554( unconstrained: bool, ) -> Result<[G; OUT_554], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[555].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[555].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_554] = [__v_5]; - if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[554].weight(); } record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -48157,12 +48712,13 @@ fn aiur_fn_555( unconstrained: bool, ) -> Result<[G; OUT_555], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -48170,24 +48726,24 @@ fn aiur_fn_555( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_555] = [__v_10]; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[555].weight(); } record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[556].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[555].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[555].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[755].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_555] = [__v_14]; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[555].weight(); } record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -48207,12 +48763,13 @@ fn aiur_fn_556( unconstrained: bool, ) -> Result<[G; OUT_556], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -48220,37 +48777,37 @@ fn aiur_fn_556( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_11: G = G::from_u64(0); let __ret: [G; OUT_556] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[556].weight(); } record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[556].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[553].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[553].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[553].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_553] = unsafe { *(record.function_queries[553].output_at(__i).as_ptr() as *const [G; OUT_553]) }; __ret }, _ => aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[557].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[557].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[557].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_557] = unsafe { *(record.function_queries[557].output_at(__i).as_ptr() as *const [G; OUT_557]) }; __ret }, _ => aiur_fn_557(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_12, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[755].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_17: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_17.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_556] = [__v_16, __v_10]; - if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[556].weight(); } record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_556] = [__v_16, __v_9]; - if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[556].weight(); } record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -48272,6 +48829,7 @@ fn aiur_fn_557( unconstrained: bool, ) -> Result<[G; OUT_557], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -48282,23 +48840,23 @@ fn aiur_fn_557( 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_557] = [__v_8]; - if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[557].weight(); } record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[551].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[551].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_3 + __v_4); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[557].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[557].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[557].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_557] = unsafe { *(record.function_queries[557].output_at(__i).as_ptr() as *const [G; OUT_557]) }; __ret }, _ => aiur_fn_557(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_557] = [__v_12]; - if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[557].weight(); } record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -48315,22 +48873,23 @@ fn aiur_fn_558( unconstrained: bool, ) -> Result<[G; OUT_558], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 + __v_9); - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[559].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[559].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[559].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_559] = unsafe { *(record.function_queries[559].output_at(__i).as_ptr() as *const [G; OUT_559]) }; __ret }, _ => aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_558] = [__v_11]; - if let Some(result) = record.function_queries[558].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[558].weight(); } record.function_queries[558].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -48345,6 +48904,7 @@ fn aiur_fn_559( unconstrained: bool, ) -> Result<[G; OUT_559], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -48352,32 +48912,32 @@ fn aiur_fn_559( match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_559] = [__v_0]; - if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[559].weight(); } record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[555].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[555].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[560].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[560].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[566].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[566].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_566] = unsafe { *(record.function_queries[566].output_at(__i).as_ptr() as *const [G; OUT_566]) }; __ret }, _ => aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_559] = [__v_0]; - if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[559].weight(); } record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 - __v_9); - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[559].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[559].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[559].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_559] = unsafe { *(record.function_queries[559].output_at(__i).as_ptr() as *const [G; OUT_559]) }; __ret }, _ => aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_559] = [__v_11]; - if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[559].weight(); } record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -48396,10 +48956,11 @@ fn aiur_fn_560( unconstrained: bool, ) -> Result<[G; OUT_560], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -48407,20 +48968,20 @@ fn aiur_fn_560( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_560] = [__v_8]; - if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[560].weight(); } record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_561(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[561].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[560].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[560].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_560] = [__v_8]; - if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[560].weight(); } record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -48440,37 +49001,38 @@ fn aiur_fn_561( unconstrained: bool, ) -> Result<[G; OUT_561], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_561] = [__v_6]; - if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[561].weight(); } record.function_queries[561].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_561] = [__v_8]; - if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[561].weight(); } record.function_queries[561].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[562].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[562].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[562].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_562] = unsafe { *(record.function_queries[562].output_at(__i).as_ptr() as *const [G; OUT_562]) }; __ret }, _ => aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[564].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[564].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[564].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_564] = unsafe { *(record.function_queries[564].output_at(__i).as_ptr() as *const [G; OUT_564]) }; __ret }, _ => aiur_fn_564(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_561] = [__v_5]; - if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[561].weight(); } record.function_queries[561].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -48487,10 +49049,11 @@ fn aiur_fn_562( unconstrained: bool, ) -> Result<[G; OUT_562], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -48498,18 +49061,18 @@ fn aiur_fn_562( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_562] = [__v_8]; - if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[562].weight(); } record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[562].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[562].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[562].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_562] = unsafe { *(record.function_queries[562].output_at(__i).as_ptr() as *const [G; OUT_562]) }; __ret }, _ => aiur_fn_562(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[563].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[563].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[563].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_563] = unsafe { *(record.function_queries[563].output_at(__i).as_ptr() as *const [G; OUT_563]) }; __ret }, _ => aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_562] = [__v_7]; - if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[562].weight(); } record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -48529,11 +49092,12 @@ fn aiur_fn_563( unconstrained: bool, ) -> Result<[G; OUT_563], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -48542,14 +49106,14 @@ fn aiur_fn_563( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_563] = [__v_11]; - if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[563].weight(); } record.function_queries[563].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[552].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[552].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[552].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -48562,7 +49126,7 @@ fn aiur_fn_563( let __v_16: G = __r_arr[9]; let __v_17: G = __r_arr[10]; let __v_18: G = __r_arr[11]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[552].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[552].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[552].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -48575,24 +49139,24 @@ fn aiur_fn_563( let __v_28: G = __r_arr[9]; let __v_29: G = __r_arr[10]; let __v_30: G = __r_arr[11]; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[547].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { 0u64 => { let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_563] = [__v_34]; - if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[563].weight(); } record.function_queries[563].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[563].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[563].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[563].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_563] = unsafe { *(record.function_queries[563].output_at(__i).as_ptr() as *const [G; OUT_563]) }; __ret }, _ => aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_563] = [__v_35]; - if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[563].weight(); } record.function_queries[563].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -48614,10 +49178,11 @@ fn aiur_fn_564( unconstrained: bool, ) -> Result<[G; OUT_564], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -48625,21 +49190,21 @@ fn aiur_fn_564( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_564] = [__v_8]; - if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[564].weight(); } record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[565].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_564] = [__v_11]; - if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[564].weight(); } record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -48659,12 +49224,13 @@ fn aiur_fn_565( unconstrained: bool, ) -> Result<[G; OUT_565], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -48673,14 +49239,14 @@ fn aiur_fn_565( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_565] = [__v_12]; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[565].weight(); } record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[552].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[552].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[552].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -48693,7 +49259,7 @@ fn aiur_fn_565( let __v_17: G = __r_arr[9]; let __v_18: G = __r_arr[10]; let __v_19: G = __r_arr[11]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[552].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[552].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[552].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -48706,17 +49272,17 @@ fn aiur_fn_565( let __v_29: G = __r_arr[9]; let __v_30: G = __r_arr[10]; let __v_31: G = __r_arr[11]; - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[547].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; match __v_32.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[753].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[565].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __ret: [G; OUT_565] = [__v_35]; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[565].weight(); } record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -48724,13 +49290,13 @@ fn aiur_fn_565( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[565].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_565] = [__v_41]; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[565].weight(); } record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -48752,15 +49318,16 @@ fn aiur_fn_566( unconstrained: bool, ) -> Result<[G; OUT_566], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -48768,19 +49335,19 @@ fn aiur_fn_566( 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_566] = [__v_8]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[566].weight(); } record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_566] = [__v_8]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[566].weight(); } record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -48788,24 +49355,24 @@ fn aiur_fn_566( 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_566] = [__v_8]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[566].weight(); } record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[335].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[335].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_566] = [__v_9]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[566].weight(); } record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[566].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[566].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_566] = unsafe { *(record.function_queries[566].output_at(__i).as_ptr() as *const [G; OUT_566]) }; __ret }, _ => aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_566] = [__v_9]; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[566].weight(); } record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -48832,8 +49399,9 @@ fn aiur_fn_567( unconstrained: bool, ) -> Result<[G; OUT_567], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -48841,18 +49409,18 @@ fn aiur_fn_567( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_567] = [__v_6]; - if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[567].weight(); } record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[567].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[567].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[567].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_567] = unsafe { *(record.function_queries[567].output_at(__i).as_ptr() as *const [G; OUT_567]) }; __ret }, _ => aiur_fn_567(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_567] = [__v_5]; - if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[567].weight(); } record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -48872,8 +49440,9 @@ fn aiur_fn_568( unconstrained: bool, ) -> Result<[G; OUT_568], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -48881,24 +49450,24 @@ fn aiur_fn_568( 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_568] = [__v_4]; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[568].weight(); } record.function_queries[568].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[568].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[568].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[568].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_568] = unsafe { *(record.function_queries[568].output_at(__i).as_ptr() as *const [G; OUT_568]) }; __ret }, _ => aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_568] = [__v_5]; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[568].weight(); } record.function_queries[568].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_568] = [__v_5]; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[568].weight(); } record.function_queries[568].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -48920,9 +49489,10 @@ fn aiur_fn_569( unconstrained: bool, ) -> Result<[G; OUT_569], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -48974,27 +49544,27 @@ fn aiur_fn_569( 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_569] = [__v_51]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[569].weight(); } record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_48, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[569].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[569].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[569].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_569] = unsafe { *(record.function_queries[569].output_at(__i).as_ptr() as *const [G; OUT_569]) }; __ret }, _ => aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_569] = [__v_53]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[569].weight(); } record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_569] = [__v_51]; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[569].weight(); } record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -49016,9 +49586,10 @@ fn aiur_fn_570( unconstrained: bool, ) -> Result<[G; OUT_570], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -49070,7 +49641,7 @@ fn aiur_fn_570( 1u64 => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_570] = [__v_49]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[570].weight(); } record.function_queries[570].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -49097,14 +49668,14 @@ fn aiur_fn_570( 1u64 => { let __v_50: G = G::from_u64(1); let __ret: [G; OUT_570] = [__v_50]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[570].weight(); } record.function_queries[570].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_48, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[570].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[570].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[570].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_570] = [__v_50]; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[570].weight(); } record.function_queries[570].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -49126,8 +49697,9 @@ fn aiur_fn_571( unconstrained: bool, ) -> Result<[G; OUT_571], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -49181,66 +49753,66 @@ fn aiur_fn_571( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_2, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[569].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[569].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[569].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_569] = unsafe { *(record.function_queries[569].output_at(__i).as_ptr() as *const [G; OUT_569]) }; __ret }, _ => aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(1); - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[570].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[570].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[570].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[570].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[570].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[570].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = (__v_52 * __v_54); let __v_56: G = G::from_u64(0); if (__v_55 != __v_56) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("mutual block mixes a definition member with inductives".to_string()) }); } - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(2); let __v_59: G = { let __a_val = __v_57.as_canonical_u64(); let __b_val = __v_58.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_59.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_571] = []; - if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[571].weight(); } record.function_queries[571].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_2, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[291].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[291].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(0); let __v_62: G = G::from_u64(1); let __v_63: G = G::from_u64(1); - let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_65: G = { let __values: [G; 3] = [__v_61, __v_50, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_65: G = { let __values: [G; 3] = [__v_61, __v_50, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_66: G = G::from_u64(1); - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = (__v_66 + __v_67); - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[559].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[559].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[559].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_559] = unsafe { *(record.function_queries[559].output_at(__i).as_ptr() as *const [G; OUT_559]) }; __ret }, _ => aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_69]; let __cu = unconstrained; let __hit = record.function_queries[568].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[568].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[568].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_568] = unsafe { *(record.function_queries[568].output_at(__i).as_ptr() as *const [G; OUT_568]) }; __ret }, _ => aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = G::from_u64(1); if (__v_70 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) }); } - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_69]; let __cu = unconstrained; let __hit = record.function_queries[567].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[567].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[567].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_567] = unsafe { *(record.function_queries[567].output_at(__i).as_ptr() as *const [G; OUT_567]) }; __ret }, _ => aiur_fn_567(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_72, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[335].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[335].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = G::from_u64(1); if (__v_73 != __v_74) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64(), msg: Some("canonical block: members are not in canonical order".to_string()) }); } let __ret: [G; OUT_571] = []; - if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[571].weight(); } record.function_queries[571].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_571] = []; - if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[571].weight(); } record.function_queries[571].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -49259,6 +49831,7 @@ fn aiur_fn_572( unconstrained: bool, ) -> Result<[G; OUT_572], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -49274,7 +49847,7 @@ fn aiur_fn_572( match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_572] = [__v_3]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { @@ -49282,13 +49855,13 @@ fn aiur_fn_572( 1u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_572] = [__v_12]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_572] = [__v_12]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -49296,33 +49869,33 @@ fn aiur_fn_572( 2u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_572] = [__v_12]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_572] = [__v_4]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_572] = [__v_12]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_572] = [__v_6]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __ret: [G; OUT_572] = [__v_8]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_572] = [__v_9]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -49342,8 +49915,9 @@ fn aiur_fn_573( unconstrained: bool, ) -> Result<[G; OUT_573], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -49352,19 +49926,19 @@ fn aiur_fn_573( 0u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_573] = [__v_5]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_573] = [__v_5]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -49378,67 +49952,67 @@ fn aiur_fn_573( let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[572].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[572].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[572].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_572] = unsafe { *(record.function_queries[572].output_at(__i).as_ptr() as *const [G; OUT_572]) }; __ret }, _ => aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); let __ret: [G; OUT_573] = [__v_20]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); let __ret: [G; OUT_573] = [__v_7]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); let __ret: [G; OUT_573] = [__v_7]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); let __ret: [G; OUT_573] = [__v_7]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); let __v_9: G = (__v_5 * __v_8); let __ret: [G; OUT_573] = [__v_9]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_573] = [__v_5]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_573] = [__v_5]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -49458,23 +50032,24 @@ fn aiur_fn_574( unconstrained: bool, ) -> Result<[G; OUT_574], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_574] = []; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[574].weight(); } record.function_queries[574].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("safe constant references an unsafe constant".to_string()) }); } let __ret: [G; OUT_574] = []; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[574].weight(); } record.function_queries[574].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -49491,36 +50066,37 @@ fn aiur_fn_575( unconstrained: bool, ) -> Result<[G; OUT_575], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[575].weight(); } record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[575].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[575].weight(); } record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[575].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[575].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[575].weight(); } record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[575].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[575].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[575].weight(); } record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { @@ -49530,7 +50106,7 @@ fn aiur_fn_575( return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("universe param index out of range".to_string()) }); } let __ret: [G; OUT_575] = []; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[575].weight(); } record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -49550,23 +50126,24 @@ fn aiur_fn_576( unconstrained: bool, ) -> Result<[G; OUT_576], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_576] = []; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[576].weight(); } record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[575].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[576].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_576] = []; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[576].weight(); } record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -49586,10 +50163,11 @@ fn aiur_fn_577( unconstrained: bool, ) -> Result<[G; OUT_577], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -49602,19 +50180,19 @@ fn aiur_fn_577( return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("loose bound variable: BVar index exceeds binder depth".to_string()) }); } let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[575].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => aiur_fn_575(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -49627,62 +50205,62 @@ fn aiur_fn_577( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[427].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[427].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[427].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_427] = unsafe { *(record.function_queries[427].output_at(__i).as_ptr() as *const [G; OUT_427]) }; __ret }, _ => aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[576].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -49702,6 +50280,7 @@ fn aiur_fn_578( unconstrained: bool, ) -> Result<[G; OUT_578], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(171); let __v_1: G = G::from_u64(104); let __v_2: G = G::from_u64(44); @@ -49734,9 +50313,9 @@ fn aiur_fn_578( let __v_29: G = G::from_u64(99); let __v_30: G = G::from_u64(202); let __v_31: G = G::from_u64(184); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_578] = [__v_32]; - if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[578].weight(); } record.function_queries[578].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -49751,6 +50330,7 @@ fn aiur_fn_579( unconstrained: bool, ) -> Result<[G; OUT_579], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -49759,11 +50339,11 @@ fn aiur_fn_579( 0u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_579] = [__v_4]; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[579].weight(); } record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -49772,16 +50352,16 @@ fn aiur_fn_579( 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[579].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[579].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[579].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_579] = unsafe { *(record.function_queries[579].output_at(__i).as_ptr() as *const [G; OUT_579]) }; __ret }, _ => aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_579] = [__v_10]; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[579].weight(); } record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_579] = [__v_8]; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[579].weight(); } record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -49800,6 +50380,7 @@ fn aiur_fn_580( unconstrained: bool, ) -> Result<[G; OUT_580], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = G::from_u64(3); let __v_1: G = G::from_u64(107); let __v_2: G = G::from_u64(99); @@ -49832,10 +50413,10 @@ fn aiur_fn_580( let __v_29: G = G::from_u64(200); let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(201); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_32]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -49863,7 +50444,7 @@ fn aiur_fn_580( return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) }); } let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[580].weight(); } record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -49883,15 +50464,16 @@ fn aiur_fn_581( unconstrained: bool, ) -> Result<[G; OUT_581], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = []; let __cu = unconstrained; let __hit = record.function_queries[578].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[578].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => aiur_fn_578(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -49902,9 +50484,9 @@ fn aiur_fn_581( break '__mc_0 [__v_7, __v_8]; }, 1u64 => { - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; let __hit = record.function_queries[379].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[379].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[379].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_379] = unsafe { *(record.function_queries[379].output_at(__i).as_ptr() as *const [G; OUT_379]) }; __ret }, _ => aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -49915,10 +50497,10 @@ fn aiur_fn_581( break '__mc_0 [__v_7, __v_8]; }, 2u64 => { - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = []; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[580].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; let __hit = record.function_queries[380].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[380].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[380].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -49929,9 +50511,9 @@ fn aiur_fn_581( break '__mc_0 [__v_7, __v_8]; }, 3u64 => { - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; let __hit = record.function_queries[381].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[381].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_381] = unsafe { *(record.function_queries[381].output_at(__i).as_ptr() as *const [G; OUT_381]) }; __ret }, _ => aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -49952,14 +50534,14 @@ fn aiur_fn_581( return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Quot constant: wrong universe param count for its kind".to_string()) }); } let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[579].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[579].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[579].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_579] = unsafe { *(record.function_queries[579].output_at(__i).as_ptr() as *const [G; OUT_579]) }; __ret }, _ => aiur_fn_579(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Quot constant: type has too few foralls for its kind".to_string()) }); } let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[581].weight(); } record.function_queries[581].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -49974,16 +50556,17 @@ fn aiur_fn_582( unconstrained: bool, ) -> Result<[G; OUT_582], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_582] = [__v_0]; - if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[582].weight(); } record.function_queries[582].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -49992,10 +50575,10 @@ fn aiur_fn_582( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_582] = [__v_8]; - if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[582].weight(); } record.function_queries[582].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -50017,29 +50600,30 @@ fn aiur_fn_583( unconstrained: bool, ) -> Result<[G; OUT_583], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("more universe levels than the inductive declares".to_string()) }); } let __ret: [G; OUT_583] = []; - if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[583].weight(); } record.function_queries[583].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -50049,12 +50633,12 @@ fn aiur_fn_583( let __v_10: G = (__v_1 - __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[583].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[583].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => aiur_fn_583(__args, record, io_buffer, __cu)? } }; if (__v_7 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return type: universe level is not Param(i) in order".to_string()) }); } let __ret: [G; OUT_583] = []; - if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[583].weight(); } record.function_queries[583].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -50081,6 +50665,7 @@ fn aiur_fn_584( unconstrained: bool, ) -> Result<[G; OUT_584], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -50089,17 +50674,17 @@ fn aiur_fn_584( match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_584] = []; - if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[584].weight(); } record.function_queries[584].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -50108,7 +50693,7 @@ fn aiur_fn_584( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[584].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[584].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_584] = unsafe { *(record.function_queries[584].output_at(__i).as_ptr() as *const [G; OUT_584]) }; __ret }, _ => aiur_fn_584(__args, record, io_buffer, __cu)? } }; let __v_14: G = (__v_2 + __v_1); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_14 - __v_15); @@ -50117,7 +50702,7 @@ fn aiur_fn_584( return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("ctor return type: param arg is not the expected param BVar".to_string()) }); } let __ret: [G; OUT_584] = []; - if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[584].weight(); } record.function_queries[584].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -50144,12 +50729,13 @@ fn aiur_fn_585( unconstrained: bool, ) -> Result<[G; OUT_585], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -50164,7 +50750,7 @@ fn aiur_fn_585( let __v_15: G = __loaded[11]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { @@ -50174,7 +50760,7 @@ fn aiur_fn_585( return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return head is a different member of the block".to_string()) }); } let __ret: [G; OUT_585] = []; - if let Some(result) = record.function_queries[585].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[585].weight(); } record.function_queries[585].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -50194,6 +50780,7 @@ fn aiur_fn_586( unconstrained: bool, ) -> Result<[G; OUT_586], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -50202,44 +50789,44 @@ fn aiur_fn_586( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_585(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[585].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[585].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[585].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_585] = unsafe { *(record.function_queries[585].output_at(__i).as_ptr() as *const [G; OUT_585]) }; __ret }, _ => aiur_fn_585(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[583].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[583].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[584].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[584].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_584] = unsafe { *(record.function_queries[584].output_at(__i).as_ptr() as *const [G; OUT_584]) }; __ret }, _ => aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_1 + __v_2); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("ctor return type: wrong number of spine arguments".to_string()) }); } - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_17, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[597].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("ctor return type: reflexive occurrence in an index argument".to_string()) }); } let __ret: [G; OUT_586] = []; - if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[586].weight(); } record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -50259,6 +50846,7 @@ fn aiur_fn_587( unconstrained: bool, ) -> Result<[G; OUT_587], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -50266,37 +50854,37 @@ fn aiur_fn_587( match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[587].weight(); } record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_15: G = G::from_u64(1); if (__v_12 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("ctor parameter type disagrees with the inductive's".to_string()) }); } let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 - __v_16); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[587].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[587].weight(); } record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -50323,15 +50911,16 @@ fn aiur_fn_588( unconstrained: bool, ) -> Result<[G; OUT_588], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[587].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_588] = []; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[588].weight(); } record.function_queries[588].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -50346,14 +50935,15 @@ fn aiur_fn_589( unconstrained: bool, ) -> Result<[G; OUT_589], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -50361,7 +50951,7 @@ fn aiur_fn_589( match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_589] = [__v_5]; - if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[589].weight(); } record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -50370,7 +50960,7 @@ fn aiur_fn_589( } }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -50380,11 +50970,11 @@ fn aiur_fn_589( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_589] = [__v_12]; - if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[589].weight(); } record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -50406,34 +50996,35 @@ fn aiur_fn_590( unconstrained: bool, ) -> Result<[G; OUT_590], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[319].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[319].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[319].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("ctor field lives in a universe above the inductive's".to_string()) }); } let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[590].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[590].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[590].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => aiur_fn_590(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_590] = []; - if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[590].weight(); } record.function_queries[590].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_590] = []; - if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[590].weight(); } record.function_queries[590].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -50450,19 +51041,20 @@ fn aiur_fn_591( unconstrained: bool, ) -> Result<[G; OUT_591], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[590].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[590].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[590].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => aiur_fn_590(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_591] = []; - if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[591].weight(); } record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -50472,10 +51064,10 @@ fn aiur_fn_591( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[591].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_591] = []; - if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[591].weight(); } record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -50497,26 +51089,27 @@ fn aiur_fn_592( unconstrained: bool, ) -> Result<[G; OUT_592], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_592] = []; - if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[592].weight(); } record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[591].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_592] = []; - if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[592].weight(); } record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -50533,12 +51126,13 @@ fn aiur_fn_593( unconstrained: bool, ) -> Result<[G; OUT_593], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[285].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __ret: [G; OUT_593] = [__v_2]; - if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[593].weight(); } record.function_queries[593].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -50553,9 +51147,10 @@ fn aiur_fn_594( unconstrained: bool, ) -> Result<[G; OUT_594], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -50563,24 +51158,24 @@ fn aiur_fn_594( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_594] = [__v_5]; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[594].weight(); } record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_594] = [__v_6]; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[594].weight(); } record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[594].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_594] = [__v_6]; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[594].weight(); } record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -50602,11 +51197,12 @@ fn aiur_fn_595( unconstrained: bool, ) -> Result<[G; OUT_595], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -50621,16 +51217,16 @@ fn aiur_fn_595( let __v_14: G = __loaded[11]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[594].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_595] = [__v_15]; - if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[595].weight(); } record.function_queries[595].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __ret: [G; OUT_595] = [__v_15]; - if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[595].weight(); } record.function_queries[595].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -50647,9 +51243,10 @@ fn aiur_fn_596( unconstrained: bool, ) -> Result<[G; OUT_596], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -50658,104 +51255,104 @@ fn aiur_fn_596( 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_596] = [__v_6]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_596] = [__v_6]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[595].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[595].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[595].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_595] = unsafe { *(record.function_queries[595].output_at(__i).as_ptr() as *const [G; OUT_595]) }; __ret }, _ => aiur_fn_595(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_596] = [__v_6]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_596] = [__v_7]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_596] = [__v_8]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_596] = [__v_8]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -50765,14 +51362,14 @@ fn aiur_fn_596( 7u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_596] = [__v_6]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_596] = [__v_6]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -50792,9 +51389,10 @@ fn aiur_fn_597( unconstrained: bool, ) -> Result<[G; OUT_597], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -50802,24 +51400,24 @@ fn aiur_fn_597( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_597] = [__v_5]; - if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[597].weight(); } record.function_queries[597].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_597] = [__v_6]; - if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[597].weight(); } record.function_queries[597].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[597].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_597] = [__v_6]; - if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[597].weight(); } record.function_queries[597].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -50841,17 +51439,18 @@ fn aiur_fn_598( unconstrained: bool, ) -> Result<[G; OUT_598], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_598] = [__v_0, __v_2]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[598].weight(); } record.function_queries[598].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -50859,19 +51458,19 @@ fn aiur_fn_598( match __v_3.as_canonical_u64() { 5u64 => { let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[598].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[598].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[598].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_598] = unsafe { *(record.function_queries[598].output_at(__i).as_ptr() as *const [G; OUT_598]) }; __ret }, _ => aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_598] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[598].weight(); } record.function_queries[598].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_598] = [__v_0, __v_2]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[598].weight(); } record.function_queries[598].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -50890,6 +51489,7 @@ fn aiur_fn_599( unconstrained: bool, ) -> Result<[G; OUT_599], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -50898,17 +51498,17 @@ fn aiur_fn_599( match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_599] = []; - if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[599].weight(); } record.function_queries[599].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -50923,9 +51523,9 @@ fn aiur_fn_599( } let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[599].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[599].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_599] = unsafe { *(record.function_queries[599].output_at(__i).as_ptr() as *const [G; OUT_599]) }; __ret }, _ => aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_599] = []; - if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[599].weight(); } record.function_queries[599].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -50952,14 +51552,15 @@ fn aiur_fn_600( unconstrained: bool, ) -> Result<[G; OUT_600], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -50975,25 +51576,25 @@ fn aiur_fn_600( match __v_6.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[583].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[583].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[599].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[599].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_599] = unsafe { *(record.function_queries[599].output_at(__i).as_ptr() as *const [G; OUT_599]) }; __ret }, _ => aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_9 + __v_10); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("recursive occurrence is not fully applied".to_string()) }); } - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_22, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[597].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("recursive occurrence: index argument mentions the block".to_string()) }); } let __ret: [G; OUT_600] = []; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[600].weight(); } record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -51013,22 +51614,23 @@ fn aiur_fn_601( unconstrained: bool, ) -> Result<[G; OUT_601], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_601] = []; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[601].weight(); } record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -51036,53 +51638,53 @@ fn aiur_fn_601( match __v_6.as_canonical_u64() { 5u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); if (__v_12 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) }); } - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[601].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[601].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[601].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_601] = unsafe { *(record.function_queries[601].output_at(__i).as_ptr() as *const [G; OUT_601]) }; __ret }, _ => aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_601] = []; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[601].weight(); } record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_13, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[595].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[595].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[595].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_595] = unsafe { *(record.function_queries[595].output_at(__i).as_ptr() as *const [G; OUT_595]) }; __ret }, _ => aiur_fn_595(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[600].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_601] = []; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[601].weight(); } record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_601] = []; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[601].weight(); } record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -51097,24 +51699,24 @@ fn aiur_fn_601( let __v_29: G = __loaded[11]; match __v_18.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_33]; let __cu = unconstrained; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[758].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_30, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[597].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) }); } let __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[602].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_601] = []; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[601].weight(); } record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -51145,6 +51747,7 @@ fn aiur_fn_602( unconstrained: bool, ) -> Result<[G; OUT_602], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -51156,13 +51759,13 @@ fn aiur_fn_602( match __v_7.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_602] = []; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[602].weight(); } record.function_queries[602].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -51179,23 +51782,23 @@ fn aiur_fn_602( 6u64 => { let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[598].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[598].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[598].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_598] = unsafe { *(record.function_queries[598].output_at(__i).as_ptr() as *const [G; OUT_598]) }; __ret }, _ => aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[603].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[603].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[603].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __v_32: G = G::from_u64(1); let __v_33: G = (__v_4 + __v_32); - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[602].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_602] = []; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[602].weight(); } record.function_queries[602].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -51217,28 +51820,29 @@ fn aiur_fn_603( unconstrained: bool, ) -> Result<[G; OUT_603], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[601].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[601].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[601].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_601] = unsafe { *(record.function_queries[601].output_at(__i).as_ptr() as *const [G; OUT_601]) }; __ret }, _ => aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[603].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[603].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[603].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_603] = []; - if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[603].weight(); } record.function_queries[603].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_603] = []; - if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[603].weight(); } record.function_queries[603].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -51255,6 +51859,7 @@ fn aiur_fn_604( unconstrained: bool, ) -> Result<[G; OUT_604], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -51262,15 +51867,15 @@ fn aiur_fn_604( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[598].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[598].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[598].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_598] = unsafe { *(record.function_queries[598].output_at(__i).as_ptr() as *const [G; OUT_598]) }; __ret }, _ => aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[603].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[603].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[603].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => aiur_fn_603(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_604] = []; - if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[604].weight(); } record.function_queries[604].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -51285,6 +51890,7 @@ fn aiur_fn_605( unconstrained: bool, ) -> Result<[G; OUT_605], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -51296,13 +51902,13 @@ fn aiur_fn_605( let __v_8: G = (__v_1 + __v_2); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[606].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[606].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_606] = unsafe { *(record.function_queries[606].output_at(__i).as_ptr() as *const [G; OUT_606]) }; __ret }, _ => aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_605] = []; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[605].weight(); } record.function_queries[605].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -51317,6 +51923,7 @@ fn aiur_fn_606( unconstrained: bool, ) -> Result<[G; OUT_606], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -51331,13 +51938,13 @@ fn aiur_fn_606( match __v_10.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_606] = []; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[606].weight(); } record.function_queries[606].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -51352,15 +51959,15 @@ fn aiur_fn_606( let __v_23: G = __loaded[11]; match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[588].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[586].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[592].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_8.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_14, __v_18, __v_5, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_14, __v_18, __v_5, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[604].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[604].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => aiur_fn_604(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -51368,7 +51975,7 @@ fn aiur_fn_606( }, } }; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_15, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); if (__v_24 != __v_25) { @@ -51385,9 +51992,9 @@ fn aiur_fn_606( } let __v_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[606].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[606].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_606] = unsafe { *(record.function_queries[606].output_at(__i).as_ptr() as *const [G; OUT_606]) }; __ret }, _ => aiur_fn_606(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_606] = []; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[606].weight(); } record.function_queries[606].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -51409,6 +52016,7 @@ fn aiur_fn_607( unconstrained: bool, ) -> Result<[G; OUT_607], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -51423,14 +52031,14 @@ fn aiur_fn_607( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[605].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[605].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[605].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_605] = unsafe { *(record.function_queries[605].output_at(__i).as_ptr() as *const [G; OUT_605]) }; __ret }, _ => aiur_fn_605(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_607] = []; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[607].weight(); } record.function_queries[607].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_607] = []; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[607].weight(); } record.function_queries[607].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -51447,6 +52055,7 @@ fn aiur_fn_608( unconstrained: bool, ) -> Result<[G; OUT_608], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -51462,16 +52071,16 @@ fn aiur_fn_608( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_608] = []; - if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[608].weight(); } record.function_queries[608].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -51525,14 +52134,14 @@ fn aiur_fn_608( match __v_14.as_canonical_u64() { 8u64 => { let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[609].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_608] = []; - if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[608].weight(); } record.function_queries[608].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_608] = []; - if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[608].weight(); } record.function_queries[608].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -51543,7 +52152,7 @@ fn aiur_fn_608( }, _ => { let __ret: [G; OUT_608] = []; - if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[608].weight(); } record.function_queries[608].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -51560,6 +52169,7 @@ fn aiur_fn_609( unconstrained: bool, ) -> Result<[G; OUT_609], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -51567,7 +52177,7 @@ fn aiur_fn_609( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -51618,7 +52228,7 @@ fn aiur_fn_609( match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_609] = []; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[609].weight(); } record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -51630,15 +52240,15 @@ fn aiur_fn_609( 1u64 => { let __v_56: G = G::from_u64(1); let __v_57: G = (__v_5 + __v_56); - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[609].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_609] = []; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[609].weight(); } record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_6, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[285].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; let __v_58: G = __loaded[1]; let __v_59: G = __loaded[2]; @@ -51653,23 +52263,23 @@ fn aiur_fn_609( let __v_68: G = __loaded[11]; match __v_57.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[588].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } }; let __v_69: G = (__v_2 + __v_3); let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); - let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_60 + __v_61); let __v_75: G = G::from_u64(1); let __v_76: G = G::from_u64(1); - let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; if (__v_60 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) }); } - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_73, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = G::from_u64(1); if (__v_79 != __v_80) { @@ -51677,17 +52287,17 @@ fn aiur_fn_609( } let __v_81: G = G::from_u64(1); let __v_82: G = (__v_5 + __v_81); - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[609].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_609] = []; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[609].weight(); } record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __v_70: G = (__v_5 + __v_69); - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[609].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_609] = []; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[609].weight(); } record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -51697,9 +52307,9 @@ fn aiur_fn_609( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_5 + __v_54); - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[609].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_609] = []; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[609].weight(); } record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -51721,6 +52331,7 @@ fn aiur_fn_610( unconstrained: bool, ) -> Result<[G; OUT_610], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -51737,13 +52348,13 @@ fn aiur_fn_610( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[293].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -51751,7 +52362,7 @@ fn aiur_fn_610( 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -51759,7 +52370,7 @@ fn aiur_fn_610( 0u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { @@ -51767,7 +52378,7 @@ fn aiur_fn_610( 0u64 => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -51777,17 +52388,17 @@ fn aiur_fn_610( 0u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); - let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[611].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_610] = [__v_20]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -51795,7 +52406,7 @@ fn aiur_fn_610( _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -51805,7 +52416,7 @@ fn aiur_fn_610( _ => { let __v_17: G = G::from_u64(0); let __ret: [G; OUT_610] = [__v_17]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -51826,6 +52437,7 @@ fn aiur_fn_611( unconstrained: bool, ) -> Result<[G; OUT_611], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -51835,15 +52447,15 @@ fn aiur_fn_611( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[612].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[612].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[612].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_612] = unsafe { *(record.function_queries[612].output_at(__i).as_ptr() as *const [G; OUT_612]) }; __ret }, _ => aiur_fn_612(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_611] = [__v_8]; - if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[611].weight(); } record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -51851,19 +52463,19 @@ fn aiur_fn_611( match __v_4.as_canonical_u64() { 5u64 => { let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[611].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_611] = [__v_12]; - if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[611].weight(); } record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_611] = [__v_8]; - if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[611].weight(); } record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -51882,6 +52494,7 @@ fn aiur_fn_612( unconstrained: bool, ) -> Result<[G; OUT_612], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -51890,30 +52503,30 @@ fn aiur_fn_612( let __v_5: G = (__v_1 - __v_2); match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[613].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[613].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => aiur_fn_613(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_612] = [__v_8]; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[612].weight(); } record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_10, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_11 - __v_15); let __v_17: G = G::from_u64(1); @@ -51925,26 +52538,26 @@ fn aiur_fn_612( }, _ => { let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 3] = [__v_20, __v_19, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_20, __v_19, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_0 [__v_21]; }, } }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = (__v_2 + __v_23); - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[612].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[612].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[612].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_612] = unsafe { *(record.function_queries[612].output_at(__i).as_ptr() as *const [G; OUT_612]) }; __ret }, _ => aiur_fn_612(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_612] = [__v_25]; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[612].weight(); } record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_612] = [__v_10]; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[612].weight(); } record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -51963,9 +52576,10 @@ fn aiur_fn_613( unconstrained: bool, ) -> Result<[G; OUT_613], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -51973,24 +52587,24 @@ fn aiur_fn_613( 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_613] = [__v_5]; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[613].weight(); } record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[614].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[614].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[614].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_614] = unsafe { *(record.function_queries[614].output_at(__i).as_ptr() as *const [G; OUT_614]) }; __ret }, _ => aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_613] = [__v_6]; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[613].weight(); } record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[613].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[613].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => aiur_fn_613(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_613] = [__v_6]; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[613].weight(); } record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52012,9 +52626,10 @@ fn aiur_fn_614( unconstrained: bool, ) -> Result<[G; OUT_614], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -52022,11 +52637,11 @@ fn aiur_fn_614( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_614] = [__v_5]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[614].weight(); } record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -52038,23 +52653,23 @@ fn aiur_fn_614( 0u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_614] = [__v_10]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[614].weight(); } record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[614].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[614].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[614].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_614] = unsafe { *(record.function_queries[614].output_at(__i).as_ptr() as *const [G; OUT_614]) }; __ret }, _ => aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_614] = [__v_10]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[614].weight(); } record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[614].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[614].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[614].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_614] = unsafe { *(record.function_queries[614].output_at(__i).as_ptr() as *const [G; OUT_614]) }; __ret }, _ => aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_614] = [__v_9]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[614].weight(); } record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52076,6 +52691,7 @@ fn aiur_fn_615( unconstrained: bool, ) -> Result<[G; OUT_615], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -52091,41 +52707,41 @@ fn aiur_fn_615( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[616].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __ret: [G; OUT_615] = [__v_14]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[615].weight(); } record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_14: G = (__v_3 + __v_4); let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_18, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_615] = [__v_23]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[615].weight(); } record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { match __v_5.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; @@ -52142,13 +52758,13 @@ fn aiur_fn_615( 6u64 => { let __v_37: G = G::from_bool((__v_32 == G::ZERO)); let __ret: [G; OUT_615] = [__v_37]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[615].weight(); } record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); let __ret: [G; OUT_615] = [__v_37]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[615].weight(); } record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52156,7 +52772,7 @@ fn aiur_fn_615( _ => { let __v_23: G = G::from_u64(0); let __ret: [G; OUT_615] = [__v_23]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[615].weight(); } record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52168,7 +52784,7 @@ fn aiur_fn_615( _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_615] = [__v_13]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[615].weight(); } record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52185,19 +52801,20 @@ fn aiur_fn_616( unconstrained: bool, ) -> Result<[G; OUT_616], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_616] = [__v_3]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[616].weight(); } record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -52251,16 +52868,16 @@ fn aiur_fn_616( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[618].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[618].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_618] = unsafe { *(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618]) }; __ret }, _ => aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_616] = [__v_52]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[616].weight(); } record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_51: G = G::from_u64(0); let __ret: [G; OUT_616] = [__v_51]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[616].weight(); } record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52281,8 +52898,9 @@ fn aiur_fn_617( unconstrained: bool, ) -> Result<[G; OUT_617], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -52337,13 +52955,13 @@ fn aiur_fn_617( 8u64 => { let __v_49: G = G::from_u64(1); let __ret: [G; OUT_617] = [__v_49]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[617].weight(); } record.function_queries[617].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_617] = [__v_49]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[617].weight(); } record.function_queries[617].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52362,9 +52980,10 @@ fn aiur_fn_618( unconstrained: bool, ) -> Result<[G; OUT_618], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -52418,13 +53037,13 @@ fn aiur_fn_618( 1u64 => { let __v_49: G = G::from_u64(1); let __ret: [G; OUT_618] = [__v_49]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[618].weight(); } record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); let __ret: [G; OUT_618] = [__v_49]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[618].weight(); } record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52434,17 +53053,17 @@ fn aiur_fn_618( 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[618].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[618].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_618] = unsafe { *(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618]) }; __ret }, _ => aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_618] = [__v_51]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[618].weight(); } record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[618].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[618].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_618] = unsafe { *(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618]) }; __ret }, _ => aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __ret: [G; OUT_618] = [__v_49]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[618].weight(); } record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52466,6 +53085,7 @@ fn aiur_fn_619( unconstrained: bool, ) -> Result<[G; OUT_619], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -52474,19 +53094,19 @@ fn aiur_fn_619( let __v_5: G = (__v_3 + __v_4); let __v_6: G = (__v_2 + __v_5); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -52494,7 +53114,7 @@ fn aiur_fn_619( match __v_15.as_canonical_u64() { 2u64 => { let __ret: [G; OUT_619] = [__v_16]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[619].weight(); } record.function_queries[619].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -52519,6 +53139,7 @@ fn aiur_fn_620( unconstrained: bool, ) -> Result<[G; OUT_620], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -52536,19 +53157,19 @@ fn aiur_fn_620( let __v_12: G = (__v_3 + __v_5); let __v_13: G = (__v_12 + __v_6); let __v_14: G = (__v_13 + __v_4); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; match __v_16.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; @@ -52556,15 +53177,15 @@ fn aiur_fn_620( match __v_22.as_canonical_u64() { 2u64 => { let __ret: [G; OUT_620] = [__v_24]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[620].weight(); } record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_620] = [__v_28]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[620].weight(); } record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52572,9 +53193,9 @@ fn aiur_fn_620( _ => { let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_620] = [__v_22]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[620].weight(); } record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52582,9 +53203,9 @@ fn aiur_fn_620( _ => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_620] = [__v_14]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[620].weight(); } record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52601,6 +53222,7 @@ fn aiur_fn_621( unconstrained: bool, ) -> Result<[G; OUT_621], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -52610,26 +53232,26 @@ fn aiur_fn_621( let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_15, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_16, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[622].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[622].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[622].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_622] = unsafe { *(record.function_queries[622].output_at(__i).as_ptr() as *const [G; OUT_622]) }; __ret }, _ => aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_621] = [__v_19]; - if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[621].weight(); } record.function_queries[621].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -52649,9 +53271,10 @@ fn aiur_fn_622( unconstrained: bool, ) -> Result<[G; OUT_622], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -52659,14 +53282,14 @@ fn aiur_fn_622( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_622] = [__v_7]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[622].weight(); } record.function_queries[622].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); if (__v_6 != __v_7) { @@ -52674,13 +53297,13 @@ fn aiur_fn_622( } let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[622].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[622].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[622].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_622] = unsafe { *(record.function_queries[622].output_at(__i).as_ptr() as *const [G; OUT_622]) }; __ret }, _ => aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_622] = [__v_12]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[622].weight(); } record.function_queries[622].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -52700,6 +53323,7 @@ fn aiur_fn_623( unconstrained: bool, ) -> Result<[G; OUT_623], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -52708,9 +53332,9 @@ fn aiur_fn_623( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_623] = [__v_6]; - if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[623].weight(); } record.function_queries[623].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -52718,14 +53342,14 @@ fn aiur_fn_623( let __v_5: G = G::from_u64(4); let __v_6: G = (__v_0 + __v_2); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[623].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_623] = [__v_12]; - if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[623].weight(); } record.function_queries[623].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52742,9 +53366,10 @@ fn aiur_fn_624( unconstrained: bool, ) -> Result<[G; OUT_624], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -52798,16 +53423,16 @@ fn aiur_fn_624( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[625].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[625].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[625].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_625] = unsafe { *(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625]) }; __ret }, _ => aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_624] = [__v_51]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[624].weight(); } record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_51: G = __loaded[0]; let __v_52: G = __loaded[1]; let __v_53: G = __loaded[2]; @@ -52823,27 +53448,27 @@ fn aiur_fn_624( match __v_51.as_canonical_u64() { 5u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[623].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = G::from_u64(0); let __v_66: G = G::from_u64(0); let __v_67: G = G::from_u64(1); let __v_68: G = G::from_u64(1); - let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); - let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_624] = [__v_73]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[624].weight(); } record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(1); let __v_64: G = G::from_u64(1); - let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_624] = [__v_65]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[624].weight(); } record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -52864,12 +53489,13 @@ fn aiur_fn_625( unconstrained: bool, ) -> Result<[G; OUT_625], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -52921,19 +53547,19 @@ fn aiur_fn_625( 1u64 => { let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); - let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_625] = [__v_54]; - if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[625].weight(); } record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[290].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[285].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; let __v_55: G = __loaded[1]; let __v_56: G = __loaded[2]; @@ -52958,29 +53584,29 @@ fn aiur_fn_625( }; let __v_66: G = __mc_out___mc_0[0]; let __v_67: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[623].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(0); let __v_70: G = G::from_u64(0); let __v_71: G = G::from_u64(1); let __v_72: G = G::from_u64(1); - let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_74: G = G::from_u64(1); let __v_75: G = (__v_4 + __v_74); - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[625].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[625].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[625].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_625] = unsafe { *(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625]) }; __ret }, _ => aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_625] = [__v_77]; - if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[625].weight(); } record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_4 + __v_52); - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[625].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[625].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[625].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_625] = unsafe { *(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625]) }; __ret }, _ => aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __ret: [G; OUT_625] = [__v_54]; - if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[625].weight(); } record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53002,10 +53628,11 @@ fn aiur_fn_626( unconstrained: bool, ) -> Result<[G; OUT_626], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -53016,48 +53643,48 @@ fn aiur_fn_626( 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_626] = [__v_9]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[626].weight(); } record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[629].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __ret: [G; OUT_626] = [__v_11]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[626].weight(); } record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[626].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[626].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[626].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_626] = [__v_11]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[626].weight(); } record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[626].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[626].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[626].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_626] = [__v_10]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[626].weight(); } record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[626].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[626].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[626].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_626] = [__v_9]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[626].weight(); } record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53079,6 +53706,7 @@ fn aiur_fn_627( unconstrained: bool, ) -> Result<[G; OUT_627], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = (__v_0 - __v_1); @@ -53086,18 +53714,18 @@ fn aiur_fn_627( 0u64 => { let __v_3: G = G::from_u64(1); let __ret: [G; OUT_627] = [__v_3]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -53109,13 +53737,13 @@ fn aiur_fn_627( 0u64 => { let __v_12: G = G::from_u64(1); let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53123,55 +53751,55 @@ fn aiur_fn_627( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 2u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_628(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[628].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[628].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[628].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_628] = unsafe { *(record.function_queries[628].output_at(__i).as_ptr() as *const [G; OUT_628]) }; __ret }, _ => aiur_fn_628(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53179,33 +53807,33 @@ fn aiur_fn_627( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53213,33 +53841,33 @@ fn aiur_fn_627( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53247,33 +53875,33 @@ fn aiur_fn_627( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 5u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53281,37 +53909,37 @@ fn aiur_fn_627( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 6u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_627] = [__v_13]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_13]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53319,7 +53947,7 @@ fn aiur_fn_627( _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53327,58 +53955,58 @@ fn aiur_fn_627( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 7u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[336].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 8u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_627] = [__v_13]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_13]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53386,7 +54014,7 @@ fn aiur_fn_627( _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_12]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53394,7 +54022,7 @@ fn aiur_fn_627( _ => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_627] = [__v_11]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53418,15 +54046,16 @@ fn aiur_fn_628( unconstrained: bool, ) -> Result<[G; OUT_628], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -53434,19 +54063,19 @@ fn aiur_fn_628( 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_628] = [__v_8]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[628].weight(); } record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_628] = [__v_8]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[628].weight(); } record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -53454,24 +54083,24 @@ fn aiur_fn_628( 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_628] = [__v_8]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[628].weight(); } record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_628(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[628].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[628].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[628].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_628] = unsafe { *(record.function_queries[628].output_at(__i).as_ptr() as *const [G; OUT_628]) }; __ret }, _ => aiur_fn_628(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_628] = [__v_9]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[628].weight(); } record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_628] = [__v_9]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[628].weight(); } record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53498,15 +54127,16 @@ fn aiur_fn_629( unconstrained: bool, ) -> Result<[G; OUT_629], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -53514,19 +54144,19 @@ fn aiur_fn_629( 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_629] = [__v_8]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[629].weight(); } record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_629] = [__v_8]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[629].weight(); } record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -53534,24 +54164,24 @@ fn aiur_fn_629( 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_629] = [__v_8]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[629].weight(); } record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[629].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_629] = [__v_9]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[629].weight(); } record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_629] = [__v_9]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[629].weight(); } record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53578,6 +54208,7 @@ fn aiur_fn_630( unconstrained: bool, ) -> Result<[G; OUT_630], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -53593,18 +54224,18 @@ fn aiur_fn_630( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[621].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[621].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_630] = [__v_13]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[630].weight(); } record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_630] = [__v_15]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[630].weight(); } record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53621,9 +54252,10 @@ fn aiur_fn_631( unconstrained: bool, ) -> Result<[G; OUT_631], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -53677,15 +54309,15 @@ fn aiur_fn_631( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[632].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[632].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __ret: [G; OUT_631] = [__v_51]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[631].weight(); } record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_631] = [__v_1]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[631].weight(); } record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53704,12 +54336,13 @@ fn aiur_fn_632( unconstrained: bool, ) -> Result<[G; OUT_632], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -53760,17 +54393,17 @@ fn aiur_fn_632( match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_632] = [__v_4]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[632].weight(); } record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[290].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_52]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; let __v_55: G = __loaded[1]; let __v_56: G = __loaded[2]; @@ -53785,11 +54418,11 @@ fn aiur_fn_632( let __v_65: G = __loaded[11]; match __v_54.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[619].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_66]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_68: G = __loaded[0]; let __v_69: G = __loaded[1]; let __v_70: G = __loaded[2]; @@ -53805,19 +54438,19 @@ fn aiur_fn_632( match __v_68.as_canonical_u64() { 5u64 => { let __ret: [G; OUT_632] = [__v_75]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[632].weight(); } record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_632] = [__v_4]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[632].weight(); } record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_632] = [__v_4]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[632].weight(); } record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53825,10 +54458,10 @@ fn aiur_fn_632( _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_3 + __v_52); - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[632].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[632].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __ret: [G; OUT_632] = [__v_54]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[632].weight(); } record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -53850,10 +54483,11 @@ fn aiur_fn_633( unconstrained: bool, ) -> Result<[G; OUT_633], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -53907,7 +54541,7 @@ fn aiur_fn_633( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[632].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[632].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; break '__mc_0 [__v_52]; }, @@ -53919,7 +54553,7 @@ fn aiur_fn_633( } }; let __v_51: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -53973,14 +54607,14 @@ fn aiur_fn_633( match __v_52.as_canonical_u64() { 8u64 => { let __v_100: G = G::from_u64(0); - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[625].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[625].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[625].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_625] = unsafe { *(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625]) }; __ret }, _ => aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; break '__mc_1 [__v_101]; }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_101: G = __loaded[0]; let __v_102: G = __loaded[1]; let __v_103: G = __loaded[2]; @@ -53996,23 +54630,23 @@ fn aiur_fn_633( match __v_101.as_canonical_u64() { 5u64 => { let __v_113: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[623].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; let __v_115: G = G::from_u64(0); let __v_116: G = G::from_u64(0); let __v_117: G = G::from_u64(1); let __v_118: G = G::from_u64(1); - let __v_119: G = { let __values: [G; 3] = [__v_117, __v_118, __v_118]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_119: G = { let __values: [G; 3] = [__v_117, __v_118, __v_118]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_120: G = G::from_u64(1); let __v_121: G = G::from_u64(1); - let __v_122: G = { let __values: [G; 6] = [__v_120, __v_121, __v_121, __v_121, __v_121, __v_121]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_123: G = { let __values: [G; 6] = [__v_115, __v_51, __v_116, __v_119, __v_114, __v_122]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_122: G = { let __values: [G; 6] = [__v_120, __v_121, __v_121, __v_121, __v_121, __v_121]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_123: G = { let __values: [G; 6] = [__v_115, __v_51, __v_116, __v_119, __v_114, __v_122]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_1 [__v_123]; }, _ => { let __v_113: G = G::from_u64(1); let __v_114: G = G::from_u64(1); - let __v_115: G = { let __values: [G; 6] = [__v_113, __v_114, __v_114, __v_114, __v_114, __v_114]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_115: G = { let __values: [G; 6] = [__v_113, __v_114, __v_114, __v_114, __v_114, __v_114]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_1 [__v_115]; }, } @@ -54022,19 +54656,19 @@ fn aiur_fn_633( } }; let __v_100: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[617].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; match __v_101.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_633] = [__v_100]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[633].weight(); } record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[634].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; let __ret: [G; OUT_633] = [__v_102]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[633].weight(); } record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -54051,11 +54685,12 @@ fn aiur_fn_634( unconstrained: bool, ) -> Result<[G; OUT_634], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -54109,15 +54744,15 @@ fn aiur_fn_634( match __v_4.as_canonical_u64() { 8u64 => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[635].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[635].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[635].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_635] = unsafe { *(record.function_queries[635].output_at(__i).as_ptr() as *const [G; OUT_635]) }; __ret }, _ => aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __ret: [G; OUT_634] = [__v_53]; - if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[634].weight(); } record.function_queries[634].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_634] = [__v_3]; - if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[634].weight(); } record.function_queries[634].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -54136,6 +54771,7 @@ fn aiur_fn_635( unconstrained: bool, ) -> Result<[G; OUT_635], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -54143,7 +54779,7 @@ fn aiur_fn_635( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -54194,17 +54830,17 @@ fn aiur_fn_635( match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_635] = [__v_5]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[635].weight(); } record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[290].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_54]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_56: G = __loaded[0]; let __v_57: G = __loaded[1]; let __v_58: G = __loaded[2]; @@ -54219,11 +54855,11 @@ fn aiur_fn_635( let __v_67: G = __loaded[11]; let __mc_out___mc_0: [G; 5] = '__mc_0: { match __v_56.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[619].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_68]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; @@ -54238,7 +54874,7 @@ fn aiur_fn_635( let __v_81: G = __loaded[11]; match __v_70.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_77, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_77, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; match __v_82.as_canonical_u64() { 1u64 => { @@ -54280,39 +54916,39 @@ fn aiur_fn_635( 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = (__v_6 + __v_73); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[635].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[635].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[635].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_635] = unsafe { *(record.function_queries[635].output_at(__i).as_ptr() as *const [G; OUT_635]) }; __ret }, _ => aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __ret: [G; OUT_635] = [__v_75]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[635].weight(); } record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[630].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[630].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[630].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_630] = unsafe { *(record.function_queries[630].output_at(__i).as_ptr() as *const [G; OUT_630]) }; __ret }, _ => aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[620].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[620].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[620].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_620] = unsafe { *(record.function_queries[620].output_at(__i).as_ptr() as *const [G; OUT_620]) }; __ret }, _ => aiur_fn_620(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[626].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[626].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[626].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; match __v_75.as_canonical_u64() { 1u64 => { let __v_76: G = G::from_u64(1); let __v_77: G = (__v_6 + __v_76); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[635].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[635].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[635].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_635] = unsafe { *(record.function_queries[635].output_at(__i).as_ptr() as *const [G; OUT_635]) }; __ret }, _ => aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; let __ret: [G; OUT_635] = [__v_78]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[635].weight(); } record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_76: G = G::from_u64(1); - let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[769].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[769].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_769] = unsafe { *(record.function_queries[769].output_at(__i).as_ptr() as *const [G; OUT_769]) }; __ret }, _ => aiur_fn_769(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); let __v_79: G = (__v_6 + __v_78); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[635].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[635].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[635].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_635] = unsafe { *(record.function_queries[635].output_at(__i).as_ptr() as *const [G; OUT_635]) }; __ret }, _ => aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; let __ret: [G; OUT_635] = [__v_80]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[635].weight(); } record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -54322,10 +54958,10 @@ fn aiur_fn_635( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_6 + __v_54); - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[635].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[635].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[635].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_635] = unsafe { *(record.function_queries[635].output_at(__i).as_ptr() as *const [G; OUT_635]) }; __ret }, _ => aiur_fn_635(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_635] = [__v_56]; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[635].weight(); } record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -54347,10 +54983,11 @@ fn aiur_fn_636( unconstrained: bool, ) -> Result<[G; OUT_636], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -54362,27 +54999,27 @@ fn aiur_fn_636( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __ret: [G; OUT_636] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[636].weight(); } record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __ret: [G; OUT_636] = [__v_10, __v_2]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[636].weight(); } record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[636].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[636].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_636] = unsafe { *(record.function_queries[636].output_at(__i).as_ptr() as *const [G; OUT_636]) }; __ret }, _ => aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_636] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[636].weight(); } record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -54404,12 +55041,13 @@ fn aiur_fn_637( unconstrained: bool, ) -> Result<[G; OUT_637], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -54421,11 +55059,11 @@ fn aiur_fn_637( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __ret: [G; OUT_637] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[637].weight(); } record.function_queries[637].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = (__v_2 - __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_12.as_canonical_u64() { @@ -54442,7 +55080,7 @@ fn aiur_fn_637( let __v_13: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[629].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; break '__mc_1 [__v_14]; }, @@ -54459,17 +55097,17 @@ fn aiur_fn_637( 1u64 => { let __v_17: G = G::from_u64(1); let __ret: [G; OUT_637] = [__v_17, __v_4]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[637].weight(); } record.function_queries[637].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_4 + __v_17); - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[637].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[637].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_637] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[637].weight(); } record.function_queries[637].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -54491,9 +55129,10 @@ fn aiur_fn_638( unconstrained: bool, ) -> Result<[G; OUT_638], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -54534,35 +55173,35 @@ fn aiur_fn_638( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_638] = [__v_40, __v_41, __v_44, __v_47]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[638].weight(); } record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_638] = [__v_3, __v_4, __v_5, __v_6]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[638].weight(); } record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[638].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; let __ret: [G; OUT_638] = [__v_10, __v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[638].weight(); } record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -54584,6 +55223,7 @@ fn aiur_fn_639( unconstrained: bool, ) -> Result<[G; OUT_639], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -54595,21 +55235,21 @@ fn aiur_fn_639( let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_6 - __v_0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_639] = [__v_9]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[639].weight(); } record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_639] = [__v_6]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[639].weight(); } record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -54618,9 +55258,9 @@ fn aiur_fn_639( let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_8 - __v_0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_639] = [__v_11]; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[639].weight(); } record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -54639,6 +55279,7 @@ fn aiur_fn_640( unconstrained: bool, ) -> Result<[G; OUT_640], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -54648,30 +55289,30 @@ fn aiur_fn_640( match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_640] = [__v_0]; - if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[640].weight(); } record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[639].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_1 - __v_13); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_5 + __v_15); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[640].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[640].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[640].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_640] = [__v_17]; - if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[640].weight(); } record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -54693,19 +55334,20 @@ fn aiur_fn_641( unconstrained: bool, ) -> Result<[G; OUT_641], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_641] = [__v_4]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[641].weight(); } record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -54715,20 +55357,20 @@ fn aiur_fn_641( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[641].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[641].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[641].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_641] = [__v_10]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[641].weight(); } record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -54738,19 +55380,19 @@ fn aiur_fn_641( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_1 - __v_15); - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_12, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[641].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[641].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[641].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __v_18: G = { let __values: [G; 3] = [__v_14, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_14, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_641] = [__v_18]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[641].weight(); } record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_641] = [__v_16]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[641].weight(); } record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -54771,6 +55413,7 @@ fn aiur_fn_642( unconstrained: bool, ) -> Result<[G; OUT_642], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -54779,7 +55422,7 @@ fn aiur_fn_642( match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_642] = [__v_0]; - if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[642].weight(); } record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -54789,16 +55432,16 @@ fn aiur_fn_642( let __v_8: G = (__v_7 - __v_3); let __v_9: G = (__v_8 + __v_2); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[642].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_642] = [__v_17]; - if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[642].weight(); } record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -54815,30 +55458,31 @@ fn aiur_fn_643( unconstrained: bool, ) -> Result<[G; OUT_643], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_643] = [__v_0]; - if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[643].weight(); } record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[643].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_643] = [__v_11]; - if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[643].weight(); } record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -54858,6 +55502,7 @@ fn aiur_fn_644( unconstrained: bool, ) -> Result<[G; OUT_644], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -54866,17 +55511,17 @@ fn aiur_fn_644( match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[642].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_644] = [__v_6]; - if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[644].weight(); } record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[643].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_644] = [__v_5]; - if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[644].weight(); } record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -54893,6 +55538,7 @@ fn aiur_fn_645( unconstrained: bool, ) -> Result<[G; OUT_645], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -54900,7 +55546,7 @@ fn aiur_fn_645( match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_645] = [__v_0]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[645].weight(); } record.function_queries[645].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -54909,16 +55555,16 @@ fn aiur_fn_645( let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_6 - __v_2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_2 + __v_13); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[645].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_645] = [__v_15]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[645].weight(); } record.function_queries[645].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -54935,26 +55581,27 @@ fn aiur_fn_646( unconstrained: bool, ) -> Result<[G; OUT_646], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_646] = [__v_0]; - if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[646].weight(); } record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(5); - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_646] = [__v_8]; - if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[646].weight(); } record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -54974,19 +55621,20 @@ fn aiur_fn_647( unconstrained: bool, ) -> Result<[G; OUT_647], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_647] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[647].weight(); } record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -54995,22 +55643,22 @@ fn aiur_fn_647( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[647].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_647] = [__v_11, __v_9]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[647].weight(); } record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -55019,21 +55667,21 @@ fn aiur_fn_647( 5u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_12, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[647].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_647] = [__v_19, __v_17]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[647].weight(); } record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_647] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[647].weight(); } record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -55054,10 +55702,11 @@ fn aiur_fn_648( unconstrained: bool, ) -> Result<[G; OUT_648], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -55065,22 +55714,22 @@ fn aiur_fn_648( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_648] = [__v_8]; - if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[648].weight(); } record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_648(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[648].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[648].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[648].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_648] = unsafe { *(record.function_queries[648].output_at(__i).as_ptr() as *const [G; OUT_648]) }; __ret }, _ => aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_648] = [__v_11]; - if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[648].weight(); } record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -55100,6 +55749,7 @@ fn aiur_fn_649( unconstrained: bool, ) -> Result<[G; OUT_649], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -55108,18 +55758,18 @@ fn aiur_fn_649( let __v_5: G = inp[5]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[643].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_649] = [__v_6]; - if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[649].weight(); } record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[653].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_649] = [__v_7]; - if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[649].weight(); } record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -55136,6 +55786,7 @@ fn aiur_fn_650( unconstrained: bool, ) -> Result<[G; OUT_650], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -55143,23 +55794,23 @@ fn aiur_fn_650( match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_650] = [__v_0]; - if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[650].weight(); } record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __v_5: G = (__v_1 - __v_2); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[650].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_650] = [__v_13]; - if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[650].weight(); } record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -55176,6 +55827,7 @@ fn aiur_fn_651( unconstrained: bool, ) -> Result<[G; OUT_651], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -55185,25 +55837,25 @@ fn aiur_fn_651( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[640].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[640].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[640].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[641].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[641].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[641].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[642].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_0 [__v_17]; }, _ => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[643].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, @@ -55211,18 +55863,18 @@ fn aiur_fn_651( }; let __v_16: G = __mc_out___mc_0[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[645].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_24, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_651] = [__v_25]; - if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[651].weight(); } record.function_queries[651].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -55237,14 +55889,15 @@ fn aiur_fn_652( unconstrained: bool, ) -> Result<[G; OUT_652], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[687].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[687].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[687].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_687] = unsafe { *(record.function_queries[687].output_at(__i).as_ptr() as *const [G; OUT_687]) }; __ret }, _ => aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_652] = [__v_4]; - if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[652].weight(); } record.function_queries[652].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -55259,6 +55912,7 @@ fn aiur_fn_653( unconstrained: bool, ) -> Result<[G; OUT_653], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -55267,23 +55921,23 @@ fn aiur_fn_653( match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_653] = [__v_0]; - if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[653].weight(); } record.function_queries[653].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = (__v_2 - __v_3); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[653].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_653] = [__v_14]; - if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[653].weight(); } record.function_queries[653].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -55300,26 +55954,27 @@ fn aiur_fn_654( unconstrained: bool, ) -> Result<[G; OUT_654], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_654] = [__v_0]; - if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[654].weight(); } record.function_queries[654].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[654].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[654].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[654].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_654] = unsafe { *(record.function_queries[654].output_at(__i).as_ptr() as *const [G; OUT_654]) }; __ret }, _ => aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_654] = [__v_8]; - if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[654].weight(); } record.function_queries[654].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -55339,6 +55994,7 @@ fn aiur_fn_655( unconstrained: bool, ) -> Result<[G; OUT_655], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -55349,14 +56005,14 @@ fn aiur_fn_655( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[638].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -55371,17 +56027,17 @@ fn aiur_fn_655( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[656].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[656].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_656] = unsafe { *(record.function_queries[656].output_at(__i).as_ptr() as *const [G; OUT_656]) }; __ret }, _ => aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __ret: [G; OUT_655] = [__v_27]; - if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[655].weight(); } record.function_queries[655].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[656].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[656].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_656] = unsafe { *(record.function_queries[656].output_at(__i).as_ptr() as *const [G; OUT_656]) }; __ret }, _ => aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __ret: [G; OUT_655] = [__v_27]; - if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[655].weight(); } record.function_queries[655].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -55398,6 +56054,7 @@ fn aiur_fn_656( unconstrained: bool, ) -> Result<[G; OUT_656], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -55409,30 +56066,30 @@ fn aiur_fn_656( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[775].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[623].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_14, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[647].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[652].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[652].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[652].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_652] = unsafe { *(record.function_queries[652].output_at(__i).as_ptr() as *const [G; OUT_652]) }; __ret }, _ => aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[670].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[670].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[670].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_670] = unsafe { *(record.function_queries[670].output_at(__i).as_ptr() as *const [G; OUT_670]) }; __ret }, _ => aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[638].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; @@ -55447,20 +56104,20 @@ fn aiur_fn_656( let __v_36: G = __loaded[11]; match __v_25.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_27, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[640].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[640].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[640].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_39, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_39, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[641].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[641].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[641].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = (__v_11 + __v_19); let __v_42: G = G::from_u64(0); - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_648(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[648].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[648].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[648].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_648] = unsafe { *(record.function_queries[648].output_at(__i).as_ptr() as *const [G; OUT_648]) }; __ret }, _ => aiur_fn_648(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(2); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_20, __v_23, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_20, __v_23, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_47: G = (__v_4 + __v_11); let __v_48: G = (__v_47 + __v_19); let __v_49: G = (__v_48 + __v_5); @@ -55470,13 +56127,13 @@ fn aiur_fn_656( let __v_53: G = (__v_52 + __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[643].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; break '__mc_0 [__v_54]; }, _ => { let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[653].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; break '__mc_0 [__v_55]; }, @@ -55484,7 +56141,7 @@ fn aiur_fn_656( }; let __v_54: G = __mc_out___mc_0[0]; let __v_55: G = G::from_u64(0); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[645].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_u64(1); let __v_58: G = (__v_49 + __v_57); @@ -55494,30 +56151,30 @@ fn aiur_fn_656( let __v_62: G = (__v_60 - __v_61); let __v_63: G = G::from_u64(0); let __v_64: G = G::from_u64(0); - let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_66: G = G::from_u64(0); - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[650].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = G::from_u64(3); let __v_69: G = G::from_u64(0); let __v_70: G = G::from_u64(0); let __v_71: G = G::from_u64(0); - let __v_72: G = { let __values: [G; 4] = [__v_69, __v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_72: G = { let __values: [G; 4] = [__v_69, __v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_73: G = G::from_u64(0); - let __v_74: G = { let __values: [G; 4] = [__v_68, __v_67, __v_72, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = { let __values: [G; 4] = [__v_68, __v_67, __v_72, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_75: G = G::from_u64(5); let __v_76: G = G::from_u64(0); - let __v_77: G = { let __values: [G; 4] = [__v_75, __v_56, __v_74, __v_76]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_77, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __v_77: G = { let __values: [G; 4] = [__v_75, __v_56, __v_74, __v_76]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_77, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_78, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_78, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_79, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_79, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_80, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_80, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; let __ret: [G; OUT_656] = [__v_81]; - if let Some(result) = record.function_queries[656].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[656].weight(); } record.function_queries[656].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -55537,6 +56194,7 @@ fn aiur_fn_657( unconstrained: bool, ) -> Result<[G; OUT_657], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -55570,9 +56228,9 @@ fn aiur_fn_657( let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; @@ -55595,9 +56253,9 @@ fn aiur_fn_657( let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); break '__mc_0 [__v_26, __v_27, __v_28, __v_34, __v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; @@ -55620,85 +56278,85 @@ fn aiur_fn_657( let __v_39: G = (__v_16 + __v_17); let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_20, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[616].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[610].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[610].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[610].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_610] = unsafe { *(record.function_queries[610].output_at(__i).as_ptr() as *const [G; OUT_610]) }; __ret }, _ => aiur_fn_610(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_45.as_canonical_u64() { 1u64 => { let __v_46: G = G::from_u64(4); let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_1 [__v_49]; }, _ => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __v_48: G = { let __values: [G; 3] = [__v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = { let __values: [G; 3] = [__v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_1 [__v_48]; }, } }; let __v_46: G = __mc_out___mc_1[0]; let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_1, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_1, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[690].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[690].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[690].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[633].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[633].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_633] = unsafe { *(record.function_queries[633].output_at(__i).as_ptr() as *const [G; OUT_633]) }; __ret }, _ => aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[664].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[664].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[664].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_664] = unsafe { *(record.function_queries[664].output_at(__i).as_ptr() as *const [G; OUT_664]) }; __ret }, _ => aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_49]; let __cu = unconstrained; let __hit = record.function_queries[667].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[667].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[667].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_667] = unsafe { *(record.function_queries[667].output_at(__i).as_ptr() as *const [G; OUT_667]) }; __ret }, _ => aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[617].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[617].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(1); - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = (__v_54 - __v_55); let __v_57: G = (__v_53 * __v_56); let __v_58: G = (__v_52 * __v_57); let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_58.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[630].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[630].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[630].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_630] = unsafe { *(record.function_queries[630].output_at(__i).as_ptr() as *const [G; OUT_630]) }; __ret }, _ => aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; break '__mc_2 [__v_59]; }, _ => { let __v_59: G = G::from_u64(1); let __v_60: G = G::from_u64(1); - let __v_61: G = { let __values: [G; 3] = [__v_59, __v_60, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_61: G = { let __values: [G; 3] = [__v_59, __v_60, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_2 [__v_61]; }, } }; let __v_59: G = __mc_out___mc_2[0]; let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[637].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[637].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; match __v_61.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[658].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_657] = []; - if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[657].weight(); } record.function_queries[657].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[636].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[636].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_636] = unsafe { *(record.function_queries[636].output_at(__i).as_ptr() as *const [G; OUT_636]) }; __ret }, _ => aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; match __v_64.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[658].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_657] = []; - if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[657].weight(); } record.function_queries[657].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -55710,7 +56368,7 @@ fn aiur_fn_657( }, _ => { let __ret: [G; OUT_657] = []; - if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[657].weight(); } record.function_queries[657].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -55732,6 +56390,7 @@ fn aiur_fn_658( unconstrained: bool, ) -> Result<[G; OUT_658], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -55750,29 +56409,29 @@ fn aiur_fn_658( let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[638].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_655(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[655].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[655].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_655] = unsafe { *(record.function_queries[655].output_at(__i).as_ptr() as *const [G; OUT_655]) }; __ret }, _ => aiur_fn_655(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[775].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_10, __v_5, __v_23, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_10, __v_5, __v_23, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[670].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[670].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[670].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_670] = unsafe { *(record.function_queries[670].output_at(__i).as_ptr() as *const [G; OUT_670]) }; __ret }, _ => aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_0, __v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_0, __v_1, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[659].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[659].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[659].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_659] = unsafe { *(record.function_queries[659].output_at(__i).as_ptr() as *const [G; OUT_659]) }; __ret }, _ => aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_2, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_2, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[660].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_12, __v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_12, __v_22, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(1); if (__v_33 != __v_34) { @@ -55785,9 +56444,9 @@ fn aiur_fn_658( return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("recursor minor count disagrees with the canonical reconstruction".to_string()) }); } let __v_35: G = G::from_u64(0); - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_11, __v_29, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_11, __v_29, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[661].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_658] = []; - if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[658].weight(); } record.function_queries[658].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -55802,6 +56461,7 @@ fn aiur_fn_659( unconstrained: bool, ) -> Result<[G; OUT_659], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -55810,11 +56470,11 @@ fn aiur_fn_659( 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_659] = [__v_4]; - if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[659].weight(); } record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -55825,13 +56485,13 @@ fn aiur_fn_659( 1u64 => { let __v_10: G = G::from_u64(0); let __ret: [G; OUT_659] = [__v_10]; - if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[659].weight(); } record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -55857,11 +56517,11 @@ fn aiur_fn_659( let __v_23: G = __mc_out___mc_0[0]; let __v_24: G = G::from_u64(1); let __v_25: G = (__v_2 + __v_24); - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[659].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[659].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[659].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_659] = unsafe { *(record.function_queries[659].output_at(__i).as_ptr() as *const [G; OUT_659]) }; __ret }, _ => aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = (__v_23 + __v_26); let __ret: [G; OUT_659] = [__v_27]; - if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[659].weight(); } record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -55883,6 +56543,7 @@ fn aiur_fn_660( unconstrained: bool, ) -> Result<[G; OUT_660], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -55903,15 +56564,15 @@ fn aiur_fn_660( 0u64 => { let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_660] = [__v_18]; - if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[660].weight(); } record.function_queries[660].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; @@ -55927,24 +56588,24 @@ fn aiur_fn_660( match __v_17.as_canonical_u64() { 6u64 => { let __v_29: G = (__v_1 + __v_14); - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[663].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[663].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => aiur_fn_663(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_14 + __v_32); - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[660].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_660] = [__v_35]; - if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[660].weight(); } record.function_queries[660].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_660] = [__v_31]; - if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[660].weight(); } record.function_queries[660].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -55963,6 +56624,7 @@ fn aiur_fn_661( unconstrained: bool, ) -> Result<[G; OUT_661], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -55972,7 +56634,7 @@ fn aiur_fn_661( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -55981,15 +56643,15 @@ fn aiur_fn_661( match __v_9.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_661] = []; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[661].weight(); } record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_10.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -56022,14 +56684,14 @@ fn aiur_fn_661( if (__v_27 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("recursor rule names a ctor index out of range".to_string()) }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; match __v_29.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_661] = []; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[661].weight(); } record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -56039,8 +56701,8 @@ fn aiur_fn_661( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[692].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[692].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[692].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_692] = unsafe { *(record.function_queries[692].output_at(__i).as_ptr() as *const [G; OUT_692]) }; __ret }, _ => aiur_fn_692(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -56049,8 +56711,8 @@ fn aiur_fn_661( } let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); if (__v_45 != __v_46) { @@ -56058,9 +56720,9 @@ fn aiur_fn_661( } let __v_47: G = G::from_u64(1); let __v_48: G = (__v_8 + __v_47); - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[661].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_661] = []; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[661].weight(); } record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -56087,6 +56749,7 @@ fn aiur_fn_662( unconstrained: bool, ) -> Result<[G; OUT_662], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -56099,19 +56762,19 @@ fn aiur_fn_662( let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = inp[11]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_662] = [__v_0]; - if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[662].weight(); } record.function_queries[662].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[752].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); @@ -56145,62 +56808,62 @@ fn aiur_fn_662( let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); - let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[752].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[752].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = (__v_6 + __v_7); let __v_54: G = (__v_53 + __v_8); let __v_55: G = (__v_54 + __v_9); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = (__v_9 - __v_13); let __v_58: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = (__v_7 + __v_8); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_61]; let __cu = unconstrained; let __hit = record.function_queries[676].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[676].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[676].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_676] = unsafe { *(record.function_queries[676].output_at(__i).as_ptr() as *const [G; OUT_676]) }; __ret }, _ => aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_62]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = (__v_55 + __v_64); let __v_66: G = G::from_u64(2); let __v_67: G = G::from_u64(0); - let __v_68: G = { let __values: [G; 4] = [__v_66, __v_50, __v_10, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_50, __v_10, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_69: G = G::from_u64(1); let __v_70: G = (__v_65 - __v_69); let __v_71: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[653].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; let __v_73: G = G::from_u64(1); let __v_74: G = (__v_65 - __v_73); let __v_75: G = (__v_74 - __v_6); let __v_76: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[653].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); let __v_79: G = (__v_65 - __v_78); let __v_80: G = (__v_79 - __v_6); let __v_81: G = (__v_80 - __v_7); let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; let __hit = record.function_queries[653].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(1); let __v_85: G = G::from_u64(1); - let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_63, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_87]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_89, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_83, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = G::from_u64(1); let __v_93: G = (__v_9 - __v_92); @@ -56208,24 +56871,24 @@ fn aiur_fn_662( let __v_95: G = (__v_94 + __v_64); let __v_96: G = G::from_u64(0); let __v_97: G = G::from_u64(0); - let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_99: G = G::from_u64(0); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[645].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __v_101: G = G::from_u64(3); let __v_102: G = G::from_u64(0); - let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_103, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[654].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[654].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[654].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_654] = unsafe { *(record.function_queries[654].output_at(__i).as_ptr() as *const [G; OUT_654]) }; __ret }, _ => aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = G::from_u64(3); let __v_106: G = G::from_u64(0); - let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_108: G = G::from_u64(1); let __v_109: G = (__v_11 + __v_108); - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; let __hit = record.function_queries[662].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[662].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_662] = unsafe { *(record.function_queries[662].output_at(__i).as_ptr() as *const [G; OUT_662]) }; __ret }, _ => aiur_fn_662(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; let __ret: [G; OUT_662] = [__v_110]; - if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[662].weight(); } record.function_queries[662].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -56245,6 +56908,7 @@ fn aiur_fn_663( unconstrained: bool, ) -> Result<[G; OUT_663], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -56258,32 +56922,32 @@ fn aiur_fn_663( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_13, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[673].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); let __v_19: G = (__v_18 + __v_16); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[674].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[674].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[674].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[686].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[686].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -56295,15 +56959,15 @@ fn aiur_fn_663( let __v_42: G = (__v_39 - __v_41); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[680].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[680].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[680].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_680] = unsafe { *(record.function_queries[680].output_at(__i).as_ptr() as *const [G; OUT_680]) }; __ret }, _ => aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[662].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[662].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_662] = unsafe { *(record.function_queries[662].output_at(__i).as_ptr() as *const [G; OUT_662]) }; __ret }, _ => aiur_fn_662(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __ret: [G; OUT_663] = [__v_49]; - if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[663].weight(); } record.function_queries[663].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -56318,10 +56982,11 @@ fn aiur_fn_664( unconstrained: bool, ) -> Result<[G; OUT_664], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -56332,20 +56997,20 @@ fn aiur_fn_664( 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_664] = [__v_11]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[664].weight(); } record.function_queries[664].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[665].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[665].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[665].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => aiur_fn_665(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[664].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[664].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[664].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_664] = unsafe { *(record.function_queries[664].output_at(__i).as_ptr() as *const [G; OUT_664]) }; __ret }, _ => aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_664] = [__v_12]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[664].weight(); } record.function_queries[664].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -56365,12 +57030,13 @@ fn aiur_fn_665( unconstrained: bool, ) -> Result<[G; OUT_665], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -56424,15 +57090,15 @@ fn aiur_fn_665( match __v_5.as_canonical_u64() { 8u64 => { let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[666].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __ret: [G; OUT_665] = [__v_54]; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[665].weight(); } record.function_queries[665].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_665] = [__v_4]; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[665].weight(); } record.function_queries[665].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -56451,6 +57117,7 @@ fn aiur_fn_666( unconstrained: bool, ) -> Result<[G; OUT_666], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -56459,7 +57126,7 @@ fn aiur_fn_666( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -56510,17 +57177,17 @@ fn aiur_fn_666( match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_666] = [__v_6]; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[666].weight(); } record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[290].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_55]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; let __v_58: G = __loaded[1]; let __v_59: G = __loaded[2]; @@ -56535,11 +57202,11 @@ fn aiur_fn_666( let __v_68: G = __loaded[11]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_57.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[619].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_69]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_71: G = __loaded[0]; let __v_72: G = __loaded[1]; let __v_73: G = __loaded[2]; @@ -56563,7 +57230,7 @@ fn aiur_fn_666( } }; let __v_83: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_69, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_69, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; match __v_84.as_canonical_u64() { 1u64 => { @@ -56573,9 +57240,9 @@ fn aiur_fn_666( break '__mc_0 [__v_85]; }, _ => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[621].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[621].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_85: G = __r_arr[0]; - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_85, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[629].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; break '__mc_0 [__v_86]; }, @@ -56597,16 +57264,16 @@ fn aiur_fn_666( match __v_69.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_666] = [__v_55]; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[666].weight(); } record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_70: G = G::from_u64(1); let __v_71: G = (__v_7 + __v_70); - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[666].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; let __ret: [G; OUT_666] = [__v_72]; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[666].weight(); } record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -56614,10 +57281,10 @@ fn aiur_fn_666( _ => { let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[666].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __ret: [G; OUT_666] = [__v_57]; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[666].weight(); } record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -56639,8 +57306,9 @@ fn aiur_fn_667( unconstrained: bool, ) -> Result<[G; OUT_667], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -56651,15 +57319,15 @@ fn aiur_fn_667( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_667] = [__v_9]; - if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[667].weight(); } record.function_queries[667].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -56684,11 +57352,11 @@ fn aiur_fn_667( }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[667].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[667].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[667].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_667] = unsafe { *(record.function_queries[667].output_at(__i).as_ptr() as *const [G; OUT_667]) }; __ret }, _ => aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_667] = [__v_23]; - if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[667].weight(); } record.function_queries[667].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -56708,10 +57376,11 @@ fn aiur_fn_668( unconstrained: bool, ) -> Result<[G; OUT_668], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[289].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -56720,7 +57389,7 @@ fn aiur_fn_668( let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[289].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -56733,22 +57402,22 @@ fn aiur_fn_668( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[71].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[71].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_71] = unsafe { *(record.function_queries[71].output_at(__i).as_ptr() as *const [G; OUT_71]) }; __ret }, _ => aiur_fn_71(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; let __hit = record.function_queries[21].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[21].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_21] = unsafe { *(record.function_queries[21].output_at(__i).as_ptr() as *const [G; OUT_21]) }; __ret }, _ => aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_668] = [__v_34]; - if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[668].weight(); } record.function_queries[668].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -56763,6 +57432,7 @@ fn aiur_fn_669( unconstrained: bool, ) -> Result<[G; OUT_669], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -56783,15 +57453,15 @@ fn aiur_fn_669( 0u64 => { let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_669] = [__v_18]; - if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[669].weight(); } record.function_queries[669].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; @@ -56806,20 +57476,20 @@ fn aiur_fn_669( let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[668].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[668].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[675].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[675].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[675].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_675] = unsafe { *(record.function_queries[675].output_at(__i).as_ptr() as *const [G; OUT_675]) }; __ret }, _ => aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_13 + __v_32); let __v_34: G = G::from_u64(1); let __v_35: G = (__v_14 + __v_34); - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[669].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[669].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[669].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_669] = unsafe { *(record.function_queries[669].output_at(__i).as_ptr() as *const [G; OUT_669]) }; __ret }, _ => aiur_fn_669(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_669] = [__v_37]; - if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[669].weight(); } record.function_queries[669].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -56841,6 +57511,7 @@ fn aiur_fn_670( unconstrained: bool, ) -> Result<[G; OUT_670], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -56848,10 +57519,10 @@ fn aiur_fn_670( let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[671].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[671].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[671].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_671] = unsafe { *(record.function_queries[671].output_at(__i).as_ptr() as *const [G; OUT_671]) }; __ret }, _ => aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_670] = [__v_7]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[670].weight(); } record.function_queries[670].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -56866,6 +57537,7 @@ fn aiur_fn_671( unconstrained: bool, ) -> Result<[G; OUT_671], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -56874,7 +57546,7 @@ fn aiur_fn_671( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -56885,15 +57557,15 @@ fn aiur_fn_671( 1u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_671] = [__v_16]; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[671].weight(); } record.function_queries[671].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -56909,28 +57581,28 @@ fn aiur_fn_671( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[669].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[669].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[669].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_669] = unsafe { *(record.function_queries[669].output_at(__i).as_ptr() as *const [G; OUT_669]) }; __ret }, _ => aiur_fn_669(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_6 + __v_29); let __v_31: G = G::from_u64(1); let __v_32: G = (__v_7 + __v_31); - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[671].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[671].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[671].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_671] = unsafe { *(record.function_queries[671].output_at(__i).as_ptr() as *const [G; OUT_671]) }; __ret }, _ => aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_28, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __ret: [G; OUT_671] = [__v_34]; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[671].weight(); } record.function_queries[671].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_7 + __v_27); - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[671].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[671].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[671].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_671] = unsafe { *(record.function_queries[671].output_at(__i).as_ptr() as *const [G; OUT_671]) }; __ret }, _ => aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_671] = [__v_29]; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[671].weight(); } record.function_queries[671].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -56952,6 +57624,7 @@ fn aiur_fn_672( unconstrained: bool, ) -> Result<[G; OUT_672], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -56964,24 +57637,24 @@ fn aiur_fn_672( let __v_7: G = (__v_1 - __v_6); let __v_8: G = (__v_7 - __v_0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_672] = [__v_10]; - if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[672].weight(); } record.function_queries[672].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_672] = [__v_9]; - if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[672].weight(); } record.function_queries[672].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -56990,9 +57663,9 @@ fn aiur_fn_672( let __v_9: G = (__v_1 - __v_8); let __v_10: G = (__v_9 - __v_0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_672] = [__v_12]; - if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[672].weight(); } record.function_queries[672].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -57011,9 +57684,10 @@ fn aiur_fn_673( unconstrained: bool, ) -> Result<[G; OUT_673], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -57022,15 +57696,15 @@ fn aiur_fn_673( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[673].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_673] = [__v_8]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[673].weight(); } record.function_queries[673].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_673] = [__v_1]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[673].weight(); } record.function_queries[673].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -57047,6 +57721,7 @@ fn aiur_fn_674( unconstrained: bool, ) -> Result<[G; OUT_674], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -57057,58 +57732,58 @@ fn aiur_fn_674( match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_674] = [__v_0]; - if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[674].weight(); } record.function_queries[674].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[672].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[672].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[672].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_672] = unsafe { *(record.function_queries[672].output_at(__i).as_ptr() as *const [G; OUT_672]) }; __ret }, _ => aiur_fn_672(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); let __v_16: G = G::from_u64(1); let __v_17: G = (__v_6 + __v_16); - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[674].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[674].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[674].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_674] = [__v_18]; - if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[674].weight(); } record.function_queries[674].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[672].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[672].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[672].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_672] = unsafe { *(record.function_queries[672].output_at(__i).as_ptr() as *const [G; OUT_672]) }; __ret }, _ => aiur_fn_672(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_1 - __v_22); let __v_24: G = G::from_u64(1); let __v_25: G = (__v_6 + __v_24); - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[674].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[674].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[674].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_674] = [__v_26]; - if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[674].weight(); } record.function_queries[674].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -57132,6 +57807,7 @@ fn aiur_fn_675( unconstrained: bool, ) -> Result<[G; OUT_675], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -57145,42 +57821,42 @@ fn aiur_fn_675( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_9 + __v_10); let __v_15: G = (__v_8 + __v_14); let __v_16: G = (__v_9 + __v_10); let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[674].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[674].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[674].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); - let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[686].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[686].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = (__v_33 + __v_34); let __v_36: G = (__v_15 + __v_35); - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_32]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_38, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[679].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[679].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[679].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_679] = unsafe { *(record.function_queries[679].output_at(__i).as_ptr() as *const [G; OUT_679]) }; __ret }, _ => aiur_fn_679(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = (__v_36 - __v_42); @@ -57188,29 +57864,29 @@ fn aiur_fn_675( let __v_45: G = (__v_43 - __v_44); let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_48, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(2); let __v_51: G = G::from_u64(0); - let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[681].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[681].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[681].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_681] = unsafe { *(record.function_queries[681].output_at(__i).as_ptr() as *const [G; OUT_681]) }; __ret }, _ => aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[680].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[680].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[680].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_680] = unsafe { *(record.function_queries[680].output_at(__i).as_ptr() as *const [G; OUT_680]) }; __ret }, _ => aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(3); let __v_57: G = G::from_u64(0); - let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[678].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[678].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[678].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_678] = unsafe { *(record.function_queries[678].output_at(__i).as_ptr() as *const [G; OUT_678]) }; __ret }, _ => aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_58, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_61, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_675] = [__v_62]; - if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[675].weight(); } record.function_queries[675].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -57225,17 +57901,18 @@ fn aiur_fn_676( unconstrained: bool, ) -> Result<[G; OUT_676], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[677].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[677].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[677].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_677] = unsafe { *(record.function_queries[677].output_at(__i).as_ptr() as *const [G; OUT_677]) }; __ret }, _ => aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[758].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_676] = [__v_6, __v_5]; - if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[676].weight(); } record.function_queries[676].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -57250,9 +57927,10 @@ fn aiur_fn_677( unconstrained: bool, ) -> Result<[G; OUT_677], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -57260,17 +57938,17 @@ fn aiur_fn_677( match __v_2.as_canonical_u64() { 5u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[677].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[677].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[677].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_677] = unsafe { *(record.function_queries[677].output_at(__i).as_ptr() as *const [G; OUT_677]) }; __ret }, _ => aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __ret: [G; OUT_677] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[677].weight(); } record.function_queries[677].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_677] = [__v_1, __v_0]; - if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[677].weight(); } record.function_queries[677].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -57287,6 +57965,7 @@ fn aiur_fn_678( unconstrained: bool, ) -> Result<[G; OUT_678], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -57295,7 +57974,7 @@ fn aiur_fn_678( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -57303,31 +57982,31 @@ fn aiur_fn_678( 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_678] = [__v_13]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[678].weight(); } record.function_queries[678].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[752].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[752].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = (__v_5 + __v_7); let __v_16: G = (__v_6 + __v_15); - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_5 - __v_9); let __v_19: G = (__v_18 + __v_7); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[676].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[676].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[676].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_676] = unsafe { *(record.function_queries[676].output_at(__i).as_ptr() as *const [G; OUT_676]) }; __ret }, _ => aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_16 + __v_24); let __v_26: G = G::from_u64(1); @@ -57340,38 +58019,38 @@ fn aiur_fn_678( let __v_33: G = (__v_31 - __v_32); let __v_34: G = G::from_u64(1); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_23, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_39, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_43, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[645].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(3); let __v_51: G = G::from_u64(0); - let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_52, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[678].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[678].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[678].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_678] = unsafe { *(record.function_queries[678].output_at(__i).as_ptr() as *const [G; OUT_678]) }; __ret }, _ => aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_678] = [__v_58]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[678].weight(); } record.function_queries[678].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -57391,10 +58070,11 @@ fn aiur_fn_679( unconstrained: bool, ) -> Result<[G; OUT_679], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -57402,20 +58082,20 @@ fn aiur_fn_679( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_679] = [__v_8]; - if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[679].weight(); } record.function_queries[679].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[679].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[679].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[679].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_679] = unsafe { *(record.function_queries[679].output_at(__i).as_ptr() as *const [G; OUT_679]) }; __ret }, _ => aiur_fn_679(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_679] = [__v_9]; - if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[679].weight(); } record.function_queries[679].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -57435,6 +58115,7 @@ fn aiur_fn_680( unconstrained: bool, ) -> Result<[G; OUT_680], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -57443,7 +58124,7 @@ fn aiur_fn_680( match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_680] = [__v_0]; - if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[680].weight(); } record.function_queries[680].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -57452,16 +58133,16 @@ fn aiur_fn_680( let __v_7: G = (__v_2 - __v_6); let __v_8: G = (__v_7 - __v_3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[680].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[680].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[680].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_680] = unsafe { *(record.function_queries[680].output_at(__i).as_ptr() as *const [G; OUT_680]) }; __ret }, _ => aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_680] = [__v_16]; - if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[680].weight(); } record.function_queries[680].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -57478,6 +58159,7 @@ fn aiur_fn_681( unconstrained: bool, ) -> Result<[G; OUT_681], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -57489,18 +58171,18 @@ fn aiur_fn_681( let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 - __v_6); let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[653].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => aiur_fn_653(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_681] = [__v_9]; - if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[681].weight(); } record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_6: G = (__v_3 - __v_2); - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[643].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_681] = [__v_7]; - if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[681].weight(); } record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -57517,14 +58199,15 @@ fn aiur_fn_682( unconstrained: bool, ) -> Result<[G; OUT_682], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[683].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[683].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[683].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_683] = unsafe { *(record.function_queries[683].output_at(__i).as_ptr() as *const [G; OUT_683]) }; __ret }, _ => aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_682] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[682].weight(); } record.function_queries[682].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -57539,33 +58222,34 @@ fn aiur_fn_683( unconstrained: bool, ) -> Result<[G; OUT_683], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[683].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[683].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[683].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_683] = unsafe { *(record.function_queries[683].output_at(__i).as_ptr() as *const [G; OUT_683]) }; __ret }, _ => aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_683] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[683].weight(); } record.function_queries[683].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -57573,18 +58257,18 @@ fn aiur_fn_683( match __v_13.as_canonical_u64() { 2u64 => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[684].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[684].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_684] = unsafe { *(record.function_queries[684].output_at(__i).as_ptr() as *const [G; OUT_684]) }; __ret }, _ => aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __ret: [G; OUT_683] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[683].weight(); } record.function_queries[683].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __ret: [G; OUT_683] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[683].weight(); } record.function_queries[683].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -57603,12 +58287,13 @@ fn aiur_fn_684( unconstrained: bool, ) -> Result<[G; OUT_684], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -57620,11 +58305,11 @@ fn aiur_fn_684( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __ret: [G; OUT_684] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[684].weight(); } record.function_queries[684].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { @@ -57632,7 +58317,7 @@ fn aiur_fn_684( break '__mc_0 [__v_12]; }, _ => { - let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[685].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[685].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[685].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_685] = unsafe { *(record.function_queries[685].output_at(__i).as_ptr() as *const [G; OUT_685]) }; __ret }, _ => aiur_fn_685(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; break '__mc_0 [__v_12]; }, @@ -57644,17 +58329,17 @@ fn aiur_fn_684( 1u64 => { let __v_14: G = G::from_u64(1); let __ret: [G; OUT_684] = [__v_14, __v_4]; - if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[684].weight(); } record.function_queries[684].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_4 + __v_14); - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[684].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[684].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_684] = unsafe { *(record.function_queries[684].output_at(__i).as_ptr() as *const [G; OUT_684]) }; __ret }, _ => aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_684] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[684].weight(); } record.function_queries[684].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -57676,10 +58361,11 @@ fn aiur_fn_685( unconstrained: bool, ) -> Result<[G; OUT_685], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -57687,11 +58373,11 @@ fn aiur_fn_685( 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_685] = [__v_6]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[685].weight(); } record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -57699,27 +58385,27 @@ fn aiur_fn_685( 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_685] = [__v_9]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[685].weight(); } record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_10, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[685].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[685].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[685].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_685] = unsafe { *(record.function_queries[685].output_at(__i).as_ptr() as *const [G; OUT_685]) }; __ret }, _ => aiur_fn_685(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_685] = [__v_12]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[685].weight(); } record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __ret: [G; OUT_685] = [__v_12]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[685].weight(); } record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -57746,6 +58432,7 @@ fn aiur_fn_686( unconstrained: bool, ) -> Result<[G; OUT_686], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -57753,7 +58440,7 @@ fn aiur_fn_686( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -57761,51 +58448,51 @@ fn aiur_fn_686( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = (__v_6 + __v_5); - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[682].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[682].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[682].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_682] = unsafe { *(record.function_queries[682].output_at(__i).as_ptr() as *const [G; OUT_682]) }; __ret }, _ => aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 3] = [__v_14, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_14, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; match __v_12.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[686].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[686].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __ret: [G; OUT_686] = [__v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[686].weight(); } record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(1); let __v_17: G = (__v_5 + __v_16); - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[686].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[686].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; let __ret: [G; OUT_686] = [__v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[686].weight(); } record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[758].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[758].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[758].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_686] = [__v_11, __v_12, __v_13, __v_0]; - if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[686].weight(); } record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -57822,11 +58509,12 @@ fn aiur_fn_687( unconstrained: bool, ) -> Result<[G; OUT_687], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -57837,15 +58525,15 @@ fn aiur_fn_687( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_687] = [__v_12]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[687].weight(); } record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -57860,26 +58548,26 @@ fn aiur_fn_687( let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[651].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[651].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[651].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_651] = unsafe { *(record.function_queries[651].output_at(__i).as_ptr() as *const [G; OUT_651]) }; __ret }, _ => aiur_fn_651(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = (__v_3 + __v_27); - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[687].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[687].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[687].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_687] = unsafe { *(record.function_queries[687].output_at(__i).as_ptr() as *const [G; OUT_687]) }; __ret }, _ => aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_687] = [__v_30]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[687].weight(); } record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[687].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[687].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[687].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_687] = unsafe { *(record.function_queries[687].output_at(__i).as_ptr() as *const [G; OUT_687]) }; __ret }, _ => aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_687] = [__v_23]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[687].weight(); } record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -57901,6 +58589,7 @@ fn aiur_fn_688( unconstrained: bool, ) -> Result<[G; OUT_688], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -57916,11 +58605,11 @@ fn aiur_fn_688( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[619].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -57935,12 +58624,12 @@ fn aiur_fn_688( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[617].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[617].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = (__v_29 - __v_30); let __v_32: G = (__v_28 * __v_31); @@ -57950,11 +58639,11 @@ fn aiur_fn_688( let __v_36: G = (__v_34 + __v_35); let __v_37: G = G::from_u64(1); let __v_38: G = (__v_36 + __v_37); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = (__v_5 + __v_6); let __v_41: G = (__v_3 + __v_40); - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[691].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[691].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[691].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() { 1u64 => { break '__mc_0 []; @@ -57967,15 +58656,15 @@ fn aiur_fn_688( return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("recursor index count differs from its inductive's".to_string()) }); } let __v_42: G = (__v_18 + __v_19); - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[689].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[689].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[689].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_689] = unsafe { *(record.function_queries[689].output_at(__i).as_ptr() as *const [G; OUT_689]) }; __ret }, _ => aiur_fn_689(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[615].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[615].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[615].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_615] = unsafe { *(record.function_queries[615].output_at(__i).as_ptr() as *const [G; OUT_615]) }; __ret }, _ => aiur_fn_615(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[607].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[607].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_607] = unsafe { *(record.function_queries[607].output_at(__i).as_ptr() as *const [G; OUT_607]) }; __ret }, _ => aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[772].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; if (__v_43 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) }); @@ -57983,9 +58672,9 @@ fn aiur_fn_688( if (__v_8 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("recursor k_flag disagrees with its inductive's K eligibility".to_string()) }); } - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[657].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_688] = []; - if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[688].weight(); } record.function_queries[688].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -58010,6 +58699,7 @@ fn aiur_fn_689( unconstrained: bool, ) -> Result<[G; OUT_689], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -58019,25 +58709,25 @@ fn aiur_fn_689( let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; if (__v_16 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("recursor major premise has the wrong number of spine args".to_string()) }); } let __ret: [G; OUT_689] = []; - if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[689].weight(); } record.function_queries[689].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -58057,6 +58747,7 @@ fn aiur_fn_690( unconstrained: bool, ) -> Result<[G; OUT_690], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = (__v_0 - __v_1); @@ -58064,23 +58755,23 @@ fn aiur_fn_690( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_690] = [__v_5]; - if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[690].weight(); } record.function_queries[690].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[690].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[690].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[690].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_690] = [__v_10]; - if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[690].weight(); } record.function_queries[690].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58097,10 +58788,11 @@ fn aiur_fn_691( unconstrained: bool, ) -> Result<[G; OUT_691], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -58109,17 +58801,17 @@ fn aiur_fn_691( match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_691] = []; - if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[691].weight(); } record.function_queries[691].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_4.as_canonical_u64() { _ => { let __v_8: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[691].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[691].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[691].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_691] = []; - if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[691].weight(); } record.function_queries[691].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58141,6 +58833,7 @@ fn aiur_fn_692( unconstrained: bool, ) -> Result<[G; OUT_692], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -58148,11 +58841,11 @@ fn aiur_fn_692( match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_692] = [__v_0, __v_2, __v_3]; - if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[692].weight(); } record.function_queries[692].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -58164,18 +58857,18 @@ fn aiur_fn_692( let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[692].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[692].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[692].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_692] = unsafe { *(record.function_queries[692].output_at(__i).as_ptr() as *const [G; OUT_692]) }; __ret }, _ => aiur_fn_692(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; let __ret: [G; OUT_692] = [__v_14, __v_15, __v_16]; - if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[692].weight(); } record.function_queries[692].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_692] = [__v_0, __v_2, __v_3]; - if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[692].weight(); } record.function_queries[692].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58194,6 +58887,7 @@ fn aiur_fn_693( unconstrained: bool, ) -> Result<[G; OUT_693], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -58207,58 +58901,58 @@ fn aiur_fn_693( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[572].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[572].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[572].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_572] = unsafe { *(record.function_queries[572].output_at(__i).as_ptr() as *const [G; OUT_572]) }; __ret }, _ => aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[496].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { @@ -58266,74 +58960,74 @@ fn aiur_fn_693( } let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); - let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[496].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[496].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[581].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[581].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[581].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_581] = unsafe { *(record.function_queries[581].output_at(__i).as_ptr() as *const [G; OUT_581]) }; __ret }, _ => aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[571].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[571].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[605].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[605].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[605].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_605] = unsafe { *(record.function_queries[605].output_at(__i).as_ptr() as *const [G; OUT_605]) }; __ret }, _ => aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[608].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[608].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[608].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_608] = unsafe { *(record.function_queries[608].output_at(__i).as_ptr() as *const [G; OUT_608]) }; __ret }, _ => aiur_fn_608(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[285].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -58348,15 +59042,15 @@ fn aiur_fn_693( let __v_31: G = __loaded[11]; match __v_20.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[588].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[586].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_32: G = (__v_23 + __v_24); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[592].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } }; if (__v_6 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("ctor parameter count differs from its inductive's".to_string()) }); } @@ -58364,15 +59058,15 @@ fn aiur_fn_693( 0u64 => { let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[604].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[604].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => aiur_fn_604(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58384,17 +59078,17 @@ fn aiur_fn_693( }, 7u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[571].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[571].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[688].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[688].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[688].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_688] = unsafe { *(record.function_queries[688].output_at(__i).as_ptr() as *const [G; OUT_688]) }; __ret }, _ => aiur_fn_688(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -58414,10 +59108,11 @@ fn aiur_fn_694( unconstrained: bool, ) -> Result<[G; OUT_694], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -58430,9 +59125,9 @@ fn aiur_fn_694( let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[693].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[693].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[693].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_693] = unsafe { *(record.function_queries[693].output_at(__i).as_ptr() as *const [G; OUT_693]) }; __ret }, _ => aiur_fn_693(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_694] = []; - if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[694].weight(); } record.function_queries[694].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -58447,8 +59142,9 @@ fn aiur_fn_695( unconstrained: bool, ) -> Result<[G; OUT_695], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -58470,81 +59166,81 @@ fn aiur_fn_695( match __v_1.as_canonical_u64() { 2u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_695] = [__v_24]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_695] = [__v_22]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_695] = [__v_21]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_695] = [__v_21]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_695] = [__v_21]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_695] = [__v_23]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_695] = [__v_21]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58561,8 +59257,9 @@ fn aiur_fn_696( unconstrained: bool, ) -> Result<[G; OUT_696], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -58570,20 +59267,20 @@ fn aiur_fn_696( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_696] = [__v_6]; - if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[696].weight(); } record.function_queries[696].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[696].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[696].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[696].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_696] = unsafe { *(record.function_queries[696].output_at(__i).as_ptr() as *const [G; OUT_696]) }; __ret }, _ => aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_696] = [__v_6]; - if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[696].weight(); } record.function_queries[696].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -58603,8 +59300,9 @@ fn aiur_fn_697( unconstrained: bool, ) -> Result<[G; OUT_697], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -58620,22 +59318,22 @@ fn aiur_fn_697( 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_697] = [__v_14]; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[697].weight(); } record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[697].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[697].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[697].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_697] = unsafe { *(record.function_queries[697].output_at(__i).as_ptr() as *const [G; OUT_697]) }; __ret }, _ => aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_697] = [__v_14]; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[697].weight(); } record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58657,8 +59355,9 @@ fn aiur_fn_698( unconstrained: bool, ) -> Result<[G; OUT_698], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -58699,22 +59398,22 @@ fn aiur_fn_698( 1u64 => { let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_698] = [__v_39]; - if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[698].weight(); } record.function_queries[698].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[698].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_698] = [__v_39]; - if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[698].weight(); } record.function_queries[698].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58736,8 +59435,9 @@ fn aiur_fn_699( unconstrained: bool, ) -> Result<[G; OUT_699], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -58789,9 +59489,9 @@ fn aiur_fn_699( 1u64 => { let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); - let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_699] = [__v_50]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[699].weight(); } record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -58799,18 +59499,18 @@ fn aiur_fn_699( 0u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[699].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_699] = [__v_52]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[699].weight(); } record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58818,18 +59518,18 @@ fn aiur_fn_699( 1u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[698].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[699].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_699] = [__v_52]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[699].weight(); } record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58837,18 +59537,18 @@ fn aiur_fn_699( 2u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[697].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[697].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[697].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_697] = unsafe { *(record.function_queries[697].output_at(__i).as_ptr() as *const [G; OUT_697]) }; __ret }, _ => aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[699].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_699] = [__v_52]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[699].weight(); } record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58875,6 +59575,7 @@ fn aiur_fn_700( unconstrained: bool, ) -> Result<[G; OUT_700], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -58925,22 +59626,22 @@ fn aiur_fn_700( let __v_47: G = inp[47]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[696].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[696].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[696].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_696] = unsafe { *(record.function_queries[696].output_at(__i).as_ptr() as *const [G; OUT_696]) }; __ret }, _ => aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_700] = [__v_52]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[700].weight(); } record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58948,16 +59649,16 @@ fn aiur_fn_700( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[697].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[697].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[697].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_697] = unsafe { *(record.function_queries[697].output_at(__i).as_ptr() as *const [G; OUT_697]) }; __ret }, _ => aiur_fn_697(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_700] = [__v_52]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[700].weight(); } record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58965,12 +59666,12 @@ fn aiur_fn_700( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_700] = [__v_50]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[700].weight(); } record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -58978,28 +59679,28 @@ fn aiur_fn_700( 3u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_700] = [__v_50]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[700].weight(); } record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, 8u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[699].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_700] = [__v_50]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[700].weight(); } record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_700] = [__v_48]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[700].weight(); } record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -59018,9 +59719,10 @@ fn aiur_fn_701( unconstrained: bool, ) -> Result<[G; OUT_701], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -59028,7 +59730,7 @@ fn aiur_fn_701( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_701] = [__v_5]; - if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[701].weight(); } record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -59037,14 +59739,14 @@ fn aiur_fn_701( 0u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_701] = [__v_6]; - if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[701].weight(); } record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[701].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[701].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_701] = unsafe { *(record.function_queries[701].output_at(__i).as_ptr() as *const [G; OUT_701]) }; __ret }, _ => aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_701] = [__v_6]; - if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[701].weight(); } record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -59066,8 +59768,9 @@ fn aiur_fn_702( unconstrained: bool, ) -> Result<[G; OUT_702], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -59121,14 +59824,14 @@ fn aiur_fn_702( let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[704].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[704].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_704] = unsafe { *(record.function_queries[704].output_at(__i).as_ptr() as *const [G; OUT_704]) }; __ret }, _ => aiur_fn_704(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[702].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[702].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59136,8 +59839,8 @@ fn aiur_fn_702( 6u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[702].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[702].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59145,8 +59848,8 @@ fn aiur_fn_702( 4u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[702].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[702].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59154,24 +59857,24 @@ fn aiur_fn_702( 5u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[702].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[702].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }, _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[700].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[700].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => aiur_fn_700(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[703].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[703].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[703].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_703] = unsafe { *(record.function_queries[703].output_at(__i).as_ptr() as *const [G; OUT_703]) }; __ret }, _ => aiur_fn_703(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_702] = []; - if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[702].weight(); } record.function_queries[702].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -59188,25 +59891,26 @@ fn aiur_fn_703( unconstrained: bool, ) -> Result<[G; OUT_703], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_703] = []; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[703].weight(); } record.function_queries[703].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[701].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[701].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_701] = unsafe { *(record.function_queries[701].output_at(__i).as_ptr() as *const [G; OUT_701]) }; __ret }, _ => aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[702].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[702].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => aiur_fn_702(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -59216,9 +59920,9 @@ fn aiur_fn_703( }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[703].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[703].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[703].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_703] = unsafe { *(record.function_queries[703].output_at(__i).as_ptr() as *const [G; OUT_703]) }; __ret }, _ => aiur_fn_703(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_703] = []; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[703].weight(); } record.function_queries[703].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -59238,11 +59942,12 @@ fn aiur_fn_704( unconstrained: bool, ) -> Result<[G; OUT_704], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -59293,16 +59998,16 @@ fn aiur_fn_704( match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_704] = []; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[704].weight(); } record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[705].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[705].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => aiur_fn_705(__args, record, io_buffer, __cu)? } }; let __v_51: G = G::from_u64(1); let __v_52: G = (__v_3 + __v_51); - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[704].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[704].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_704] = unsafe { *(record.function_queries[704].output_at(__i).as_ptr() as *const [G; OUT_704]) }; __ret }, _ => aiur_fn_704(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_704] = []; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[704].weight(); } record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -59322,6 +60027,7 @@ fn aiur_fn_705( unconstrained: bool, ) -> Result<[G; OUT_705], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -59370,11 +60076,11 @@ fn aiur_fn_705( let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[290].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_50: G = __loaded[0]; let __v_51: G = __loaded[1]; let __v_52: G = __loaded[2]; @@ -59387,9 +60093,9 @@ fn aiur_fn_705( let __v_59: G = __loaded[9]; let __v_60: G = __loaded[10]; let __v_61: G = __loaded[11]; - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[693].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[693].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[693].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_693] = unsafe { *(record.function_queries[693].output_at(__i).as_ptr() as *const [G; OUT_693]) }; __ret }, _ => aiur_fn_693(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_705] = []; - if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[705].weight(); } record.function_queries[705].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -59404,19 +60110,20 @@ fn aiur_fn_706( unconstrained: bool, ) -> Result<[G; OUT_706], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[45].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[21].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[21].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_21] = unsafe { *(record.function_queries[21].output_at(__i).as_ptr() as *const [G; OUT_21]) }; __ret }, _ => aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_706] = [__v_8]; - if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[706].weight(); } record.function_queries[706].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -59431,22 +60138,23 @@ fn aiur_fn_707( unconstrained: bool, ) -> Result<[G; OUT_707], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[45].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[45].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[21].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[21].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_21] = unsafe { *(record.function_queries[21].output_at(__i).as_ptr() as *const [G; OUT_21]) }; __ret }, _ => aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_707] = [__v_10]; - if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[707].weight(); } record.function_queries[707].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -59461,24 +60169,25 @@ fn aiur_fn_708( unconstrained: bool, ) -> Result<[G; OUT_708], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[706].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_708] = [__v_5, __v_10, __v_4]; - if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[708].weight(); } record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { @@ -59514,29 +60223,29 @@ fn aiur_fn_708( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_708] = [__v_35, __v_38, __v_2]; - if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[708].weight(); } record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[708].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[708].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[708].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => aiur_fn_708(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[708].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[708].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[708].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => aiur_fn_708(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[707].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[707].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[707].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_707] = unsafe { *(record.function_queries[707].output_at(__i).as_ptr() as *const [G; OUT_707]) }; __ret }, _ => aiur_fn_707(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_708] = [__v_9, __v_10, __v_8]; - if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[708].weight(); } record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -59556,8 +60265,9 @@ fn aiur_fn_709( unconstrained: bool, ) -> Result<[G; OUT_709], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -59595,9 +60305,9 @@ fn aiur_fn_709( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -59608,11 +60318,11 @@ fn aiur_fn_709( let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[708].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[708].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[708].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => aiur_fn_708(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_51: G = __loaded[0]; let __v_52: G = __loaded[1]; let __v_53: G = __loaded[2]; @@ -59653,7 +60363,7 @@ fn aiur_fn_709( if (__v_39 != __v_84) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_84.as_canonical_u64(), msg: Some("assumption tree: wrong tag4 variant".to_string()) }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; @@ -59765,7 +60475,7 @@ fn aiur_fn_709( return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } let __ret: [G; OUT_709] = [__v_49]; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[709].weight(); } record.function_queries[709].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -59780,6 +60490,7 @@ fn aiur_fn_710( unconstrained: bool, ) -> Result<[G; OUT_710], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -59787,26 +60498,26 @@ fn aiur_fn_710( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_710] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; - if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[710].weight(); } record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[773].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[773].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => aiur_fn_773(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[710].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; @@ -59814,7 +60525,7 @@ fn aiur_fn_710( let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; let __ret: [G; OUT_710] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; - if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[710].weight(); } record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -59834,6 +60545,7 @@ fn aiur_fn_711( unconstrained: bool, ) -> Result<[G; OUT_711], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -59842,10 +60554,10 @@ fn aiur_fn_711( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[757].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_711] = [__v_8]; - if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[711].weight(); } record.function_queries[711].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -59860,6 +60572,7 @@ fn aiur_fn_712( unconstrained: bool, ) -> Result<[G; OUT_712], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -59874,18 +60587,18 @@ fn aiur_fn_712( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[711].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[711].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[711].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_711] = unsafe { *(record.function_queries[711].output_at(__i).as_ptr() as *const [G; OUT_711]) }; __ret }, _ => aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_712] = []; - if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[712].weight(); } record.function_queries[712].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[711].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[711].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[711].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_711] = unsafe { *(record.function_queries[711].output_at(__i).as_ptr() as *const [G; OUT_711]) }; __ret }, _ => aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { @@ -59898,7 +60611,7 @@ fn aiur_fn_712( }, } }; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -59952,14 +60665,14 @@ fn aiur_fn_712( let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_15.as_canonical_u64() { 8u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[704].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[704].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_704] = unsafe { *(record.function_queries[704].output_at(__i).as_ptr() as *const [G; OUT_704]) }; __ret }, _ => aiur_fn_704(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, 7u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -59967,8 +60680,8 @@ fn aiur_fn_712( 6u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -59976,8 +60689,8 @@ fn aiur_fn_712( 4u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -59985,24 +60698,24 @@ fn aiur_fn_712( 5u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }, _ => { - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }; - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[700].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[700].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => aiur_fn_700(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = G::from_u64(0); - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[713].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[713].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_713] = unsafe { *(record.function_queries[713].output_at(__i).as_ptr() as *const [G; OUT_713]) }; __ret }, _ => aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_712] = []; - if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[712].weight(); } record.function_queries[712].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -60021,6 +60734,7 @@ fn aiur_fn_713( unconstrained: bool, ) -> Result<[G; OUT_713], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -60037,22 +60751,22 @@ fn aiur_fn_713( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_713] = []; - if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[713].weight(); } record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[701].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[701].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_701] = unsafe { *(record.function_queries[701].output_at(__i).as_ptr() as *const [G; OUT_701]) }; __ret }, _ => aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -60062,9 +60776,9 @@ fn aiur_fn_713( }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_2 + __v_20); - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[713].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[713].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_713] = unsafe { *(record.function_queries[713].output_at(__i).as_ptr() as *const [G; OUT_713]) }; __ret }, _ => aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_713] = []; - if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[713].weight(); } record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -60084,6 +60798,7 @@ fn aiur_fn_714( unconstrained: bool, ) -> Result<[G; OUT_714], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -60097,22 +60812,22 @@ fn aiur_fn_714( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_714] = []; - if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[714].weight(); } record.function_queries[714].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[714].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_714] = []; - if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[714].weight(); } record.function_queries[714].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -60132,20 +60847,21 @@ fn aiur_fn_715( unconstrained: bool, ) -> Result<[G; OUT_715], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[709].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_0 [__v_6]; }, 0u64 => { - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[709].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -60157,7 +60873,7 @@ fn aiur_fn_715( let __v_4: G = __mc_out___mc_0[0]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[710].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -60166,16 +60882,16 @@ fn aiur_fn_715( let __v_12: G = __r_arr[5]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[710].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[714].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_715] = []; - if let Some(result) = record.function_queries[715].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[715].weight(); } record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -60190,8 +60906,9 @@ fn aiur_fn_716( unconstrained: bool, ) -> Result<[G; OUT_716], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -60199,16 +60916,16 @@ fn aiur_fn_716( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __ret: [G; OUT_716] = [__v_3, __v_4, __v_2]; - if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[716].weight(); } record.function_queries[716].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); let __ret: [G; OUT_716] = [__v_5, __v_3, __v_4]; - if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[716].weight(); } record.function_queries[716].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -60228,6 +60945,7 @@ fn aiur_fn_717( unconstrained: bool, ) -> Result<[G; OUT_717], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { @@ -60235,11 +60953,11 @@ fn aiur_fn_717( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __ret: [G; OUT_717] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; - if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[717].weight(); } record.function_queries[717].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -60251,7 +60969,7 @@ fn aiur_fn_717( let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(0); let __ret: [G; OUT_717] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[717].weight(); } record.function_queries[717].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -60268,6 +60986,7 @@ fn aiur_fn_718( unconstrained: bool, ) -> Result<[G; OUT_718], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { @@ -60275,16 +60994,16 @@ fn aiur_fn_718( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __ret: [G; OUT_718] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[718].weight(); } record.function_queries[718].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); let __ret: [G; OUT_718] = [__v_4, __v_2, __v_3]; - if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[718].weight(); } record.function_queries[718].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -60301,6 +61020,7 @@ fn aiur_fn_719( unconstrained: bool, ) -> Result<[G; OUT_719], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { @@ -60308,16 +61028,16 @@ fn aiur_fn_719( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __ret: [G; OUT_719] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[719].weight(); } record.function_queries[719].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); let __ret: [G; OUT_719] = [__v_4, __v_2, __v_3]; - if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[719].weight(); } record.function_queries[719].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -60334,6 +61054,7 @@ fn aiur_fn_720( unconstrained: bool, ) -> Result<[G; OUT_720], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { @@ -60341,11 +61062,11 @@ fn aiur_fn_720( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __ret: [G; OUT_720] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[720].weight(); } record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { @@ -60353,21 +61074,21 @@ fn aiur_fn_720( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[720].weight(); } record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[720].weight(); } record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[720].weight(); } record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -60389,6 +61110,7 @@ fn aiur_fn_721( unconstrained: bool, ) -> Result<[G; OUT_721], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { @@ -60396,11 +61118,11 @@ fn aiur_fn_721( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __ret: [G; OUT_721] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[721].weight(); } record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { @@ -60408,28 +61130,28 @@ fn aiur_fn_721( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[721].weight(); } record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[721].weight(); } record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[721].weight(); } record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(3); let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[721].weight(); } record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -60451,6 +61173,7 @@ fn aiur_fn_722( unconstrained: bool, ) -> Result<[G; OUT_722], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -60460,19 +61183,19 @@ fn aiur_fn_722( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_722] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[722].weight(); } record.function_queries[722].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -60491,7 +61214,7 @@ fn aiur_fn_722( let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -60500,13 +61223,13 @@ fn aiur_fn_722( let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[722].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_722] = [__v_39, __v_37]; - if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[722].weight(); } record.function_queries[722].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -60523,6 +61246,7 @@ fn aiur_fn_723( unconstrained: bool, ) -> Result<[G; OUT_723], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { @@ -60530,11 +61254,11 @@ fn aiur_fn_723( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __ret: [G; OUT_723] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[723].weight(); } record.function_queries[723].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -60544,12 +61268,12 @@ fn aiur_fn_723( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[722].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); let __ret: [G; OUT_723] = [__v_13, __v_11, __v_12]; - if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[723].weight(); } record.function_queries[723].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -60566,8 +61290,9 @@ fn aiur_fn_724( unconstrained: bool, ) -> Result<[G; OUT_724], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -60586,11 +61311,11 @@ fn aiur_fn_724( let __v_15: G = __b1_out[5]; let __v_16: G = __b1_out[6]; let __v_17: G = __b1_out[7]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_11, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -60601,7 +61326,7 @@ fn aiur_fn_724( let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -60612,7 +61337,7 @@ fn aiur_fn_724( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -60623,7 +61348,7 @@ fn aiur_fn_724( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -60634,12 +61359,12 @@ fn aiur_fn_724( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; let __ret: [G; OUT_724] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[724].weight(); } record.function_queries[724].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -60654,8 +61379,9 @@ fn aiur_fn_725( unconstrained: bool, ) -> Result<[G; OUT_725], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -60665,7 +61391,7 @@ fn aiur_fn_725( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[724].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[724].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -60708,7 +61434,7 @@ fn aiur_fn_725( let __v_49: G = __r_arr[39]; let __v_50: G = __r_arr[40]; let __ret: [G; OUT_725] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[725].weight(); } record.function_queries[725].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -60723,6 +61449,7 @@ fn aiur_fn_726( unconstrained: bool, ) -> Result<[G; OUT_726], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -60732,19 +61459,19 @@ fn aiur_fn_726( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_726] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[726].weight(); } record.function_queries[726].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_725(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[725].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[725].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[725].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_725] = unsafe { *(record.function_queries[725].output_at(__i).as_ptr() as *const [G; OUT_725]) }; __ret }, _ => aiur_fn_725(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -60794,7 +61521,7 @@ fn aiur_fn_726( let __v_56: G = __r_arr[46]; let __v_57: G = __r_arr[47]; let __v_58: G = __r_arr[48]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; @@ -60803,13 +61530,13 @@ fn aiur_fn_726( let __v_64: G = __r_arr[5]; let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; let __hit = record.function_queries[726].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[726].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[726].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_726] = unsafe { *(record.function_queries[726].output_at(__i).as_ptr() as *const [G; OUT_726]) }; __ret }, _ => aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = G::from_u64(0); - let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_726] = [__v_70, __v_68]; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[726].weight(); } record.function_queries[726].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -60826,6 +61553,7 @@ fn aiur_fn_727( unconstrained: bool, ) -> Result<[G; OUT_727], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { @@ -60833,11 +61561,11 @@ fn aiur_fn_727( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __ret: [G; OUT_727] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[727].weight(); } record.function_queries[727].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -60847,12 +61575,12 @@ fn aiur_fn_727( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[726].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[726].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[726].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_726] = unsafe { *(record.function_queries[726].output_at(__i).as_ptr() as *const [G; OUT_726]) }; __ret }, _ => aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); let __ret: [G; OUT_727] = [__v_13, __v_11, __v_12]; - if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[727].weight(); } record.function_queries[727].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -60869,11 +61597,12 @@ fn aiur_fn_728( unconstrained: bool, ) -> Result<[G; OUT_728], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -60903,15 +61632,15 @@ fn aiur_fn_728( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[720].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[720].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[720].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[720].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -60922,26 +61651,26 @@ fn aiur_fn_728( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); let __ret: [G; OUT_728] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[728].weight(); } record.function_queries[728].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -60952,7 +61681,7 @@ fn aiur_fn_728( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -60963,7 +61692,7 @@ fn aiur_fn_728( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -60974,30 +61703,30 @@ fn aiur_fn_728( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_17, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[727].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[727].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_727] = unsafe { *(record.function_queries[727].output_at(__i).as_ptr() as *const [G; OUT_727]) }; __ret }, _ => aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = G::from_u64(1); let __v_68: G = G::from_u64(0); let __ret: [G; OUT_728] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66]; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[728].weight(); } record.function_queries[728].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61008,7 +61737,7 @@ fn aiur_fn_728( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -61019,7 +61748,7 @@ fn aiur_fn_728( let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -61030,7 +61759,7 @@ fn aiur_fn_728( let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -61041,7 +61770,7 @@ fn aiur_fn_728( let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -61052,17 +61781,17 @@ fn aiur_fn_728( let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[723].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = G::from_u64(2); let __ret: [G; OUT_728] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[728].weight(); } record.function_queries[728].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -61082,8 +61811,9 @@ fn aiur_fn_729( unconstrained: bool, ) -> Result<[G; OUT_729], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -61093,7 +61823,7 @@ fn aiur_fn_729( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_728(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[728].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[728].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_728] = unsafe { *(record.function_queries[728].output_at(__i).as_ptr() as *const [G; OUT_728]) }; __ret }, _ => aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -61150,7 +61880,7 @@ fn aiur_fn_729( let __v_63: G = __r_arr[53]; let __v_64: G = __r_arr[54]; let __ret: [G; OUT_729] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; - if let Some(result) = record.function_queries[729].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[729].weight(); } record.function_queries[729].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -61165,6 +61895,7 @@ fn aiur_fn_730( unconstrained: bool, ) -> Result<[G; OUT_730], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -61174,19 +61905,19 @@ fn aiur_fn_730( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_730] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[730].weight(); } record.function_queries[730].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_729(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[729].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[729].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_729] = unsafe { *(record.function_queries[729].output_at(__i).as_ptr() as *const [G; OUT_729]) }; __ret }, _ => aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -61250,7 +61981,7 @@ fn aiur_fn_730( let __v_70: G = __r_arr[60]; let __v_71: G = __r_arr[61]; let __v_72: G = __r_arr[62]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = __r_arr[2]; @@ -61259,13 +61990,13 @@ fn aiur_fn_730( let __v_78: G = __r_arr[5]; let __v_79: G = __r_arr[6]; let __v_80: G = __r_arr[7]; - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; let __hit = record.function_queries[730].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[730].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_730] = unsafe { *(record.function_queries[730].output_at(__i).as_ptr() as *const [G; OUT_730]) }; __ret }, _ => aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = G::from_u64(0); - let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_730] = [__v_84, __v_82]; - if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[730].weight(); } record.function_queries[730].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -61282,11 +62013,12 @@ fn aiur_fn_731( unconstrained: bool, ) -> Result<[G; OUT_731], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -61316,15 +62048,15 @@ fn aiur_fn_731( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[720].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[720].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[720].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[720].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61335,30 +62067,30 @@ fn aiur_fn_731( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); let __ret: [G; OUT_731] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -61369,7 +62101,7 @@ fn aiur_fn_731( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -61380,7 +62112,7 @@ fn aiur_fn_731( let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -61391,7 +62123,7 @@ fn aiur_fn_731( let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -61402,7 +62134,7 @@ fn aiur_fn_731( let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -61413,25 +62145,25 @@ fn aiur_fn_731( let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[723].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = G::from_u64(1); let __ret: [G; OUT_731] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -61442,22 +62174,22 @@ fn aiur_fn_731( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = G::from_u64(2); let __v_45: G = G::from_u64(0); let __ret: [G; OUT_731] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[721].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -61468,18 +62200,18 @@ fn aiur_fn_731( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = G::from_u64(3); let __v_45: G = G::from_u64(0); let __ret: [G; OUT_731] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61490,7 +62222,7 @@ fn aiur_fn_731( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -61501,18 +62233,18 @@ fn aiur_fn_731( let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; let __v_51: G = G::from_u64(4); let __v_52: G = G::from_u64(0); let __ret: [G; OUT_731] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61523,18 +62255,18 @@ fn aiur_fn_731( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(5); let __v_42: G = G::from_u64(0); let __ret: [G; OUT_731] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61545,18 +62277,18 @@ fn aiur_fn_731( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(6); let __v_42: G = G::from_u64(0); let __ret: [G; OUT_731] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61567,14 +62299,14 @@ fn aiur_fn_731( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(7); let __v_42: G = G::from_u64(0); let __ret: [G; OUT_731] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { @@ -61582,11 +62314,11 @@ fn aiur_fn_731( 0u64 => { let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_0 [__v_30, __v_11]; }, 1u64 => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61596,7 +62328,7 @@ fn aiur_fn_731( let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[730].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[730].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_730] = unsafe { *(record.function_queries[730].output_at(__i).as_ptr() as *const [G; OUT_730]) }; __ret }, _ => aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; break '__mc_0 [__v_37, __v_38]; @@ -61611,7 +62343,7 @@ fn aiur_fn_731( let __v_30: G = G::from_u64(8); let __v_31: G = G::from_u64(0); let __ret: [G; OUT_731] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -61631,8 +62363,9 @@ fn aiur_fn_732( unconstrained: bool, ) -> Result<[G; OUT_732], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -61653,13 +62386,13 @@ fn aiur_fn_732( let __v_18: G = __loaded[17]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[21].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[21].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_21] = unsafe { *(record.function_queries[21].output_at(__i).as_ptr() as *const [G; OUT_21]) }; __ret }, _ => aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_732] = [__v_23]; - if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[732].weight(); } record.function_queries[732].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -61674,24 +62407,25 @@ fn aiur_fn_733( unconstrained: bool, ) -> Result<[G; OUT_733], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_733] = [__v_1]; - if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[733].weight(); } record.function_queries[733].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_733] = [__v_1]; - if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[733].weight(); } record.function_queries[733].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_733] = [__v_1]; - if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[733].weight(); } record.function_queries[733].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -61711,25 +62445,26 @@ fn aiur_fn_734( unconstrained: bool, ) -> Result<[G; OUT_734], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_734] = []; - if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[734].weight(); } record.function_queries[734].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[733].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[733].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition kind != real".to_string()) }); } let __ret: [G; OUT_734] = []; - if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[734].weight(); } record.function_queries[734].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -61749,25 +62484,26 @@ fn aiur_fn_735( unconstrained: bool, ) -> Result<[G; OUT_735], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_735] = []; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[735].weight(); } record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[733].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[733].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition safety != real".to_string()) }); } let __ret: [G; OUT_735] = []; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[735].weight(); } record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -61787,25 +62523,26 @@ fn aiur_fn_736( unconstrained: bool, ) -> Result<[G; OUT_736], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_736] = []; - if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[736].weight(); } record.function_queries[736].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[99].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[99].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[99].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => aiur_fn_99(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[99].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[99].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[99].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => aiur_fn_99(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed quotient kind != real".to_string()) }); } let __ret: [G; OUT_736] = []; - if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[736].weight(); } record.function_queries[736].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -61825,13 +62562,14 @@ fn aiur_fn_737( unconstrained: bool, ) -> Result<[G; OUT_737], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_737] = []; - if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[737].weight(); } record.function_queries[737].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -61839,7 +62577,7 @@ fn aiur_fn_737( return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed flag != real".to_string()) }); } let __ret: [G; OUT_737] = []; - if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[737].weight(); } record.function_queries[737].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -61859,6 +62597,7 @@ fn aiur_fn_738( unconstrained: bool, ) -> Result<[G; OUT_738], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -61879,7 +62618,7 @@ fn aiur_fn_738( match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_738] = []; - if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[738].weight(); } record.function_queries[738].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -61908,7 +62647,7 @@ fn aiur_fn_738( return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } let __ret: [G; OUT_738] = []; - if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[738].weight(); } record.function_queries[738].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -61928,17 +62667,18 @@ fn aiur_fn_739( unconstrained: bool, ) -> Result<[G; OUT_739], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_739] = []; - if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[739].weight(); } record.function_queries[739].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -61971,7 +62711,7 @@ fn aiur_fn_739( let __v_32: G = __loaded[29]; let __v_33: G = __loaded[30]; let __v_34: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; @@ -62101,7 +62841,7 @@ fn aiur_fn_739( return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } let __ret: [G; OUT_739] = []; - if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[739].weight(); } record.function_queries[739].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -62121,19 +62861,20 @@ fn aiur_fn_740( unconstrained: bool, ) -> Result<[G; OUT_740], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_740] = []; - if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[740].weight(); } record.function_queries[740].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_732(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[732].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -62166,7 +62907,7 @@ fn aiur_fn_740( let __v_33: G = __loaded[29]; let __v_34: G = __loaded[30]; let __v_35: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_36: G = __loaded[0]; let __v_37: G = __loaded[1]; let __v_38: G = __loaded[2]; @@ -62296,7 +63037,7 @@ fn aiur_fn_740( return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } let __ret: [G; OUT_740] = []; - if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[740].weight(); } record.function_queries[740].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -62316,6 +63057,7 @@ fn aiur_fn_741( unconstrained: bool, ) -> Result<[G; OUT_741], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -62326,7 +63068,7 @@ fn aiur_fn_741( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __loaded: [G; 19] = { let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 19 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 19] = __args[..19].try_into().unwrap(); __arr }; + let __loaded: [G; 19] = { let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 19 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 19] = __args[..19].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -62348,7 +63090,7 @@ fn aiur_fn_741( let __v_28: G = __loaded[18]; match __v_10.as_canonical_u64() { 1u64 => { - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; @@ -62363,7 +63105,7 @@ fn aiur_fn_741( match __v_29.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_741] = []; - if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[741].weight(); } record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -62372,7 +63114,7 @@ fn aiur_fn_741( } }, 0u64 => { - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; @@ -62391,7 +63133,7 @@ fn aiur_fn_741( match __v_30.as_canonical_u64() { _ => { let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } }; if (__v_11 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } @@ -62440,7 +63182,7 @@ fn aiur_fn_741( if (__v_37 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) }); } - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -62449,9 +63191,9 @@ fn aiur_fn_741( let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[741].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_741] = []; - if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[741].weight(); } record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -62480,13 +63222,14 @@ fn aiur_fn_742( unconstrained: bool, ) -> Result<[G; OUT_742], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_742] = []; - if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[742].weight(); } record.function_queries[742].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -62498,9 +63241,9 @@ fn aiur_fn_742( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[741].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => aiur_fn_741(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_742] = []; - if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[742].weight(); } record.function_queries[742].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -62520,6 +63263,7 @@ fn aiur_fn_743( unconstrained: bool, ) -> Result<[G; OUT_743], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -62569,7 +63313,7 @@ fn aiur_fn_743( let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[767].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => aiur_fn_767(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; @@ -62608,14 +63352,14 @@ fn aiur_fn_743( _ => { match __v_49.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_743] = []; - if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[743].weight(); } record.function_queries[743].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -62634,9 +63378,10 @@ fn aiur_fn_744( unconstrained: bool, ) -> Result<[G; OUT_744], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 50] = { let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 50 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 50] = __args[..50].try_into().unwrap(); __arr }; + let __loaded: [G; 50] = { let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 50 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 50] = __args[..50].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -62690,14 +63435,14 @@ fn aiur_fn_744( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_744] = []; - if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[744].weight(); } record.function_queries[744].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[743].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[743].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[743].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_743] = unsafe { *(record.function_queries[743].output_at(__i).as_ptr() as *const [G; OUT_743]) }; __ret }, _ => aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[744].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_744] = []; - if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[744].weight(); } record.function_queries[744].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -62717,19 +63462,20 @@ fn aiur_fn_745( unconstrained: bool, ) -> Result<[G; OUT_745], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_745] = []; - if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[745].weight(); } record.function_queries[745].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[744].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_745] = []; - if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[745].weight(); } record.function_queries[745].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -62749,6 +63495,7 @@ fn aiur_fn_746( unconstrained: bool, ) -> Result<[G; OUT_746], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -62854,13 +63601,13 @@ fn aiur_fn_746( 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[734].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[735].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[735].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[735].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_735] = unsafe { *(record.function_queries[735].output_at(__i).as_ptr() as *const [G; OUT_735]) }; __ret }, _ => aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_746] = []; - if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[746].weight(); } record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -62875,14 +63622,14 @@ fn aiur_fn_746( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[745].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[745].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[745].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_745] = unsafe { *(record.function_queries[745].output_at(__i).as_ptr() as *const [G; OUT_745]) }; __ret }, _ => aiur_fn_745(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_746] = []; - if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[746].weight(); } record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -62897,17 +63644,17 @@ fn aiur_fn_746( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[742].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_746] = []; - if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[746].weight(); } record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -62934,9 +63681,10 @@ fn aiur_fn_747( unconstrained: bool, ) -> Result<[G; OUT_747], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 64] = { let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 64 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 64] = __args[..64].try_into().unwrap(); __arr }; + let __loaded: [G; 64] = { let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 64 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 64] = __args[..64].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -63004,11 +63752,11 @@ fn aiur_fn_747( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_747] = []; - if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[747].weight(); } record.function_queries[747].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[764].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -63054,10 +63802,10 @@ fn aiur_fn_747( let __v_108: G = __r_arr[42]; let __v_109: G = __r_arr[43]; let __v_110: G = __r_arr[44]; - let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; let __hit = record.function_queries[746].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[746].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[746].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_746] = unsafe { *(record.function_queries[746].output_at(__i).as_ptr() as *const [G; OUT_746]) }; __ret }, _ => aiur_fn_746(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[747].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[747].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[747].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_747] = unsafe { *(record.function_queries[747].output_at(__i).as_ptr() as *const [G; OUT_747]) }; __ret }, _ => aiur_fn_747(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_747] = []; - if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[747].weight(); } record.function_queries[747].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -63077,6 +63825,7 @@ fn aiur_fn_748( unconstrained: bool, ) -> Result<[G; OUT_748], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -63132,7 +63881,7 @@ fn aiur_fn_748( let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -63189,13 +63938,13 @@ fn aiur_fn_748( 0u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[734].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[735].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[735].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[735].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_735] = unsafe { *(record.function_queries[735].output_at(__i).as_ptr() as *const [G; OUT_735]) }; __ret }, _ => aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -63210,17 +63959,17 @@ fn aiur_fn_748( 1u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[742].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -63235,11 +63984,11 @@ fn aiur_fn_748( 2u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -63254,11 +64003,11 @@ fn aiur_fn_748( 3u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[736].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[736].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[736].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_736] = unsafe { *(record.function_queries[736].output_at(__i).as_ptr() as *const [G; OUT_736]) }; __ret }, _ => aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -63273,11 +64022,11 @@ fn aiur_fn_748( 4u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[739].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -63292,10 +64041,10 @@ fn aiur_fn_748( 5u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[739].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -63310,10 +64059,10 @@ fn aiur_fn_748( 6u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[739].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -63328,10 +64077,10 @@ fn aiur_fn_748( 7u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[739].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -63344,9 +64093,9 @@ fn aiur_fn_748( 8u64 => { match __v_1.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_56, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[747].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[747].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[747].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_747] = unsafe { *(record.function_queries[747].output_at(__i).as_ptr() as *const [G; OUT_747]) }; __ret }, _ => aiur_fn_747(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_748] = []; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -63373,18 +64122,19 @@ fn aiur_fn_749( unconstrained: bool, ) -> Result<[G; OUT_749], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[709].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[413].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[413].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Contains: target is not a leaf of the claimed tree".to_string()) }); } let __ret: [G; OUT_749] = []; - if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[749].weight(); } record.function_queries[749].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -63399,6 +64149,7 @@ fn aiur_fn_750( unconstrained: bool, ) -> Result<[G; OUT_750], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -63412,7 +64163,7 @@ fn aiur_fn_750( let __v_9: G = __io_pair.0; let __v_10: G = __io_pair.1; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_9, __v_10]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_9, __v_10]; let __cu = true; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(103); let __v_14: G = G::from_u64(230); @@ -63448,7 +64199,7 @@ fn aiur_fn_750( let __v_44: G = G::from_u64(91); let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); let __v_50: G = G::from_u64(0); @@ -63459,14 +64210,14 @@ fn aiur_fn_750( let __v_55: G = G::from_u64(0); let __v_56: G = G::from_u64(0); let __v_57: G = G::from_u64(0); - let __v_58: G = { let __values: [G; 8] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_59: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 8] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_59: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_60: G = G::from_u64(1); let __v_61: G = G::from_u64(1); - let __v_62: G = { let __values: [G; 34] = [__v_60, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __v_62: G = { let __values: [G; 34] = [__v_60, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_63]; let __cu = unconstrained; let __hit = record.function_queries[23].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[23].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -63499,7 +64250,7 @@ fn aiur_fn_750( let __v_93: G = __r_arr[29]; let __v_94: G = __r_arr[30]; let __v_95: G = __r_arr[31]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -63622,26 +64373,26 @@ fn aiur_fn_750( } match __v_97.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[716].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; match __v_188.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_186]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_186]; let __cu = unconstrained; let __hit = record.function_queries[702].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[702].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => aiur_fn_702(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[750].weight(); } record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_189]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[709].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_191: G = __r_arr[0]; let __v_192: G = G::from_u64(1); let __v_193: G = G::from_u64(1); - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[710].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_194: G = __r_arr[0]; let __v_195: G = __r_arr[1]; let __v_196: G = __r_arr[2]; @@ -63651,9 +64402,9 @@ fn aiur_fn_750( let __v_200: G = G::from_u64(1); let __v_201: G = G::from_u64(1); let __v_202: G = G::from_u64(0); - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[750].weight(); } record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -63662,23 +64413,23 @@ fn aiur_fn_750( } }, 5u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[716].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[715].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[750].weight(); } record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[731].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[731].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[731].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_731] = unsafe { *(record.function_queries[731].output_at(__i).as_ptr() as *const [G; OUT_731]) }; __ret }, _ => aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; @@ -63734,21 +64485,21 @@ fn aiur_fn_750( let __v_240: G = __r_arr[52]; let __v_241: G = __r_arr[53]; let __v_242: G = __r_arr[54]; - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241]; let __cu = unconstrained; let __hit = record.function_queries[748].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[748].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_748] = unsafe { *(record.function_queries[748].output_at(__i).as_ptr() as *const [G; OUT_748]) }; __ret }, _ => aiur_fn_748(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[750].weight(); } record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_186, __v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_186, __v_188]; let __cu = unconstrained; let __hit = record.function_queries[749].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[749].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[749].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_749] = unsafe { *(record.function_queries[749].output_at(__i).as_ptr() as *const [G; OUT_749]) }; __ret }, _ => aiur_fn_749(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_750] = []; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[750].weight(); } record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -63768,6 +64519,7 @@ fn aiur_fn_751( unconstrained: bool, ) -> Result<[G; OUT_751], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -63776,9 +64528,9 @@ fn aiur_fn_751( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_750(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[750].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[750].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_750] = unsafe { *(record.function_queries[750].output_at(__i).as_ptr() as *const [G; OUT_750]) }; __ret }, _ => aiur_fn_750(__args, record, io_buffer, __cu)? } }; let __ret: [G; OUT_751] = []; - if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[751].weight(); } record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -63793,24 +64545,25 @@ fn aiur_fn_752( unconstrained: bool, ) -> Result<[G; OUT_752], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_752] = [__v_2]; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[752].weight(); } record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __ret: [G; OUT_752] = [__v_5]; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[752].weight(); } record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -63830,9 +64583,10 @@ fn aiur_fn_753( unconstrained: bool, ) -> Result<[G; OUT_753], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -63841,19 +64595,19 @@ fn aiur_fn_753( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_753] = [__v_9]; - if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[753].weight(); } record.function_queries[753].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[753].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_753] = [__v_7]; - if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[753].weight(); } record.function_queries[753].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -63873,8 +64627,9 @@ fn aiur_fn_754( unconstrained: bool, ) -> Result<[G; OUT_754], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -63896,11 +64651,11 @@ fn aiur_fn_754( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __ret: [G; OUT_754] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[754].weight(); } record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[754].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[754].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[754].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_754] = unsafe { *(record.function_queries[754].output_at(__i).as_ptr() as *const [G; OUT_754]) }; __ret }, _ => aiur_fn_754(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -63909,7 +64664,7 @@ fn aiur_fn_754( let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -63919,7 +64674,7 @@ fn aiur_fn_754( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __ret: [G; OUT_754] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[754].weight(); } record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -63939,9 +64694,10 @@ fn aiur_fn_755( unconstrained: bool, ) -> Result<[G; OUT_755], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -63949,16 +64705,16 @@ fn aiur_fn_755( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_755] = [__v_1]; - if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[755].weight(); } record.function_queries[755].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[755].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_755] = [__v_8]; - if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[755].weight(); } record.function_queries[755].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -63978,8 +64734,9 @@ fn aiur_fn_756( unconstrained: bool, ) -> Result<[G; OUT_756], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -63994,11 +64751,11 @@ fn aiur_fn_756( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __ret: [G; OUT_756] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[756].weight(); } record.function_queries[756].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[756].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[756].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -64007,7 +64764,7 @@ fn aiur_fn_756( let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -64017,7 +64774,7 @@ fn aiur_fn_756( let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __ret: [G; OUT_756] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[756].weight(); } record.function_queries[756].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64037,6 +64794,7 @@ fn aiur_fn_757( unconstrained: bool, ) -> Result<[G; OUT_757], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -64048,18 +64806,18 @@ fn aiur_fn_757( match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_757] = [__v_7]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[757].weight(); } record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -64069,10 +64827,10 @@ fn aiur_fn_757( let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[757].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_757] = [__v_21]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[757].weight(); } record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64080,14 +64838,14 @@ fn aiur_fn_757( match __v_21.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_757] = [__v_4]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[757].weight(); } record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[757].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_757] = [__v_22]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[757].weight(); } record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -64111,14 +64869,15 @@ fn aiur_fn_758( unconstrained: bool, ) -> Result<[G; OUT_758], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[776].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[776].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[776].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => aiur_fn_776(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __ret: [G; OUT_758] = [__v_4]; - if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[758].weight(); } record.function_queries[758].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -64133,25 +64892,26 @@ fn aiur_fn_759( unconstrained: bool, ) -> Result<[G; OUT_759], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_759] = [__v_1]; - if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[759].weight(); } record.function_queries[759].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_759] = [__v_7]; - if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[759].weight(); } record.function_queries[759].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64171,8 +64931,9 @@ fn aiur_fn_760( unconstrained: bool, ) -> Result<[G; OUT_760], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -64180,16 +64941,16 @@ fn aiur_fn_760( 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_760] = [__v_4]; - if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[760].weight(); } record.function_queries[760].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_4 + __v_5); let __ret: [G; OUT_760] = [__v_6]; - if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[760].weight(); } record.function_queries[760].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64209,8 +64970,9 @@ fn aiur_fn_761( unconstrained: bool, ) -> Result<[G; OUT_761], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -64258,11 +65020,11 @@ fn aiur_fn_761( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __ret: [G; OUT_761] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; - if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[761].weight(); } record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[761].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[761].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[761].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_761] = unsafe { *(record.function_queries[761].output_at(__i).as_ptr() as *const [G; OUT_761]) }; __ret }, _ => aiur_fn_761(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -64271,7 +65033,7 @@ fn aiur_fn_761( let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; @@ -64281,7 +65043,7 @@ fn aiur_fn_761( let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; let __ret: [G; OUT_761] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; - if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[761].weight(); } record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64301,18 +65063,19 @@ fn aiur_fn_762( unconstrained: bool, ) -> Result<[G; OUT_762], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_762] = [__v_4]; - if let Some(result) = record.function_queries[762].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[762].weight(); } record.function_queries[762].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64332,8 +65095,9 @@ fn aiur_fn_763( unconstrained: bool, ) -> Result<[G; OUT_763], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -64348,16 +65112,16 @@ fn aiur_fn_763( 1u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_763] = [__v_11]; - if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[763].weight(); } record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[763].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_11 + __v_12); let __ret: [G; OUT_763] = [__v_13]; - if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[763].weight(); } record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64377,6 +65141,7 @@ fn aiur_fn_764( unconstrained: bool, ) -> Result<[G; OUT_764], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -64386,7 +65151,7 @@ fn aiur_fn_764( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -64436,16 +65201,16 @@ fn aiur_fn_764( let __v_55: G = __loaded[46]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_764] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; - if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[764].weight(); } record.function_queries[764].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -64454,7 +65219,7 @@ fn aiur_fn_764( let __v_62: G = __r_arr[5]; let __v_63: G = __r_arr[6]; let __v_64: G = __r_arr[7]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[764].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -64501,7 +65266,7 @@ fn aiur_fn_764( let __v_108: G = __r_arr[43]; let __v_109: G = __r_arr[44]; let __ret: [G; OUT_764] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; - if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[764].weight(); } record.function_queries[764].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64526,8 +65291,9 @@ fn aiur_fn_765( unconstrained: bool, ) -> Result<[G; OUT_765], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -64586,11 +65352,11 @@ fn aiur_fn_765( let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); let __ret: [G; OUT_765] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; - if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[765].weight(); } record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[765].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[765].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[765].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => aiur_fn_765(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -64599,7 +65365,7 @@ fn aiur_fn_765( let __v_53: G = __r_arr[5]; let __v_54: G = __r_arr[6]; let __v_55: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -64609,7 +65375,7 @@ fn aiur_fn_765( let __v_62: G = __r_arr[6]; let __v_63: G = __r_arr[7]; let __ret: [G; OUT_765] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; - if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[765].weight(); } record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64629,8 +65395,9 @@ fn aiur_fn_766( unconstrained: bool, ) -> Result<[G; OUT_766], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -64653,11 +65420,11 @@ fn aiur_fn_766( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __ret: [G; OUT_766] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[766].weight(); } record.function_queries[766].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[766].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -64666,7 +65433,7 @@ fn aiur_fn_766( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -64676,7 +65443,7 @@ fn aiur_fn_766( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __ret: [G; OUT_766] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[766].weight(); } record.function_queries[766].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64696,6 +65463,7 @@ fn aiur_fn_767( unconstrained: bool, ) -> Result<[G; OUT_767], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -64705,7 +65473,7 @@ fn aiur_fn_767( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -64744,16 +65512,16 @@ fn aiur_fn_767( let __v_44: G = __loaded[35]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_767] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; - if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[767].weight(); } record.function_queries[767].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -64762,7 +65530,7 @@ fn aiur_fn_767( let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[767].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => aiur_fn_767(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -64798,7 +65566,7 @@ fn aiur_fn_767( let __v_86: G = __r_arr[32]; let __v_87: G = __r_arr[33]; let __ret: [G; OUT_767] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; - if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[767].weight(); } record.function_queries[767].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64823,8 +65591,9 @@ fn aiur_fn_768( unconstrained: bool, ) -> Result<[G; OUT_768], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -64832,13 +65601,13 @@ fn aiur_fn_768( 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_768] = [__v_4]; - if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[768].weight(); } record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_768] = [__v_4]; - if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[768].weight(); } record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64858,12 +65627,13 @@ fn aiur_fn_769( unconstrained: bool, ) -> Result<[G; OUT_769], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -64875,19 +65645,19 @@ fn aiur_fn_769( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_769] = [__v_15]; - if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[769].weight(); } record.function_queries[769].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[769].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[769].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_769] = unsafe { *(record.function_queries[769].output_at(__i).as_ptr() as *const [G; OUT_769]) }; __ret }, _ => aiur_fn_769(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_769] = [__v_13]; - if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[769].weight(); } record.function_queries[769].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64907,19 +65677,20 @@ fn aiur_fn_770( unconstrained: bool, ) -> Result<[G; OUT_770], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_770] = [__v_4]; - if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[770].weight(); } record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -64928,11 +65699,11 @@ fn aiur_fn_770( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_770] = [__v_9]; - if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[770].weight(); } record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64954,27 +65725,28 @@ fn aiur_fn_771( unconstrained: bool, ) -> Result<[G; OUT_771], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_771] = [__v_0]; - if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[771].weight(); } record.function_queries[771].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_771] = [__v_7]; - if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[771].weight(); } record.function_queries[771].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -64996,8 +65768,9 @@ fn aiur_fn_772( unconstrained: bool, ) -> Result<[G; OUT_772], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -65007,16 +65780,16 @@ fn aiur_fn_772( 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_772] = [__v_6]; - if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[772].weight(); } record.function_queries[772].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[772].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_6 + __v_7); let __ret: [G; OUT_772] = [__v_8]; - if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[772].weight(); } record.function_queries[772].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -65036,6 +65809,7 @@ fn aiur_fn_773( unconstrained: bool, ) -> Result<[G; OUT_773], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -65044,7 +65818,7 @@ fn aiur_fn_773( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[777].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -65056,7 +65830,7 @@ fn aiur_fn_773( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __ret: [G; OUT_773] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[773].weight(); } record.function_queries[773].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -65076,6 +65850,7 @@ fn aiur_fn_774( unconstrained: bool, ) -> Result<[G; OUT_774], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -65085,7 +65860,7 @@ fn aiur_fn_774( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -65101,19 +65876,19 @@ fn aiur_fn_774( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_774] = [__v_23]; - if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[774].weight(); } record.function_queries[774].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[774].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_774] = [__v_21]; - if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[774].weight(); } record.function_queries[774].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -65133,8 +65908,9 @@ fn aiur_fn_775( unconstrained: bool, ) -> Result<[G; OUT_775], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -65145,16 +65921,16 @@ fn aiur_fn_775( 1u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_775] = [__v_7]; - if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[775].weight(); } record.function_queries[775].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[775].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_7 + __v_8); let __ret: [G; OUT_775] = [__v_9]; - if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[775].weight(); } record.function_queries[775].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -65174,25 +65950,26 @@ fn aiur_fn_776( unconstrained: bool, ) -> Result<[G; OUT_776], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_776] = [__v_1]; - if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[776].weight(); } record.function_queries[776].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; + let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[776].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[776].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[776].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => aiur_fn_776(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_776] = [__v_7]; - if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[776].weight(); } record.function_queries[776].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -65212,6 +65989,7 @@ fn aiur_fn_777( unconstrained: bool, ) -> Result<[G; OUT_777], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -65226,23 +66004,23 @@ fn aiur_fn_777( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_777] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; - if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[777].weight(); } record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -65252,14 +66030,14 @@ fn aiur_fn_777( let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[777].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[778].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -65267,7 +66045,7 @@ fn aiur_fn_777( let __v_31: G = __r_arr[4]; let __v_32: G = __r_arr[5]; let __ret: [G; OUT_777] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; - if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[777].weight(); } record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -65275,21 +66053,21 @@ fn aiur_fn_777( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_777] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; - if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[777].weight(); } record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[777].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[778].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -65297,7 +66075,7 @@ fn aiur_fn_777( let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; let __ret: [G; OUT_777] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[777].weight(); } record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65321,6 +66099,7 @@ fn aiur_fn_778( unconstrained: bool, ) -> Result<[G; OUT_778], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -65338,7 +66117,7 @@ fn aiur_fn_778( let __v_14: G = inp[14]; match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[779].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -65346,15 +66125,15 @@ fn aiur_fn_778( let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; let __ret: [G; OUT_778] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; - if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[778].weight(); } record.function_queries[778].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_778] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; - if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[778].weight(); } record.function_queries[778].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65371,6 +66150,7 @@ fn aiur_fn_779( unconstrained: bool, ) -> Result<[G; OUT_779], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -65389,7 +66169,7 @@ fn aiur_fn_779( 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -65404,17 +66184,17 @@ fn aiur_fn_779( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(1); - let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -65429,13 +66209,13 @@ fn aiur_fn_779( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); - let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -65443,7 +66223,7 @@ fn aiur_fn_779( 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; @@ -65458,17 +66238,17 @@ fn aiur_fn_779( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -65483,22 +66263,22 @@ fn aiur_fn_779( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65506,10 +66286,10 @@ fn aiur_fn_779( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65517,7 +66297,7 @@ fn aiur_fn_779( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -65532,22 +66312,22 @@ fn aiur_fn_779( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65555,10 +66335,10 @@ fn aiur_fn_779( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65568,10 +66348,10 @@ fn aiur_fn_779( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65579,10 +66359,10 @@ fn aiur_fn_779( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65594,7 +66374,7 @@ fn aiur_fn_779( 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; @@ -65609,17 +66389,17 @@ fn aiur_fn_779( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -65634,22 +66414,22 @@ fn aiur_fn_779( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65657,10 +66437,10 @@ fn aiur_fn_779( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65668,7 +66448,7 @@ fn aiur_fn_779( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -65683,22 +66463,22 @@ fn aiur_fn_779( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65706,10 +66486,10 @@ fn aiur_fn_779( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65719,10 +66499,10 @@ fn aiur_fn_779( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65730,10 +66510,10 @@ fn aiur_fn_779( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65743,7 +66523,7 @@ fn aiur_fn_779( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -65758,13 +66538,13 @@ fn aiur_fn_779( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); - let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -65772,7 +66552,7 @@ fn aiur_fn_779( 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; @@ -65787,17 +66567,17 @@ fn aiur_fn_779( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -65812,22 +66592,22 @@ fn aiur_fn_779( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65835,10 +66615,10 @@ fn aiur_fn_779( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65846,7 +66626,7 @@ fn aiur_fn_779( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -65861,22 +66641,22 @@ fn aiur_fn_779( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65884,10 +66664,10 @@ fn aiur_fn_779( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65897,10 +66677,10 @@ fn aiur_fn_779( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65908,10 +66688,10 @@ fn aiur_fn_779( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65923,7 +66703,7 @@ fn aiur_fn_779( 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; @@ -65938,17 +66718,17 @@ fn aiur_fn_779( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -65963,22 +66743,22 @@ fn aiur_fn_779( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65986,10 +66766,10 @@ fn aiur_fn_779( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -65997,7 +66777,7 @@ fn aiur_fn_779( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -66012,22 +66792,22 @@ fn aiur_fn_779( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66035,10 +66815,10 @@ fn aiur_fn_779( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66048,10 +66828,10 @@ fn aiur_fn_779( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66059,10 +66839,10 @@ fn aiur_fn_779( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66076,7 +66856,7 @@ fn aiur_fn_779( 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -66091,17 +66871,17 @@ fn aiur_fn_779( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -66116,22 +66896,22 @@ fn aiur_fn_779( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66139,10 +66919,10 @@ fn aiur_fn_779( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66150,7 +66930,7 @@ fn aiur_fn_779( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -66165,22 +66945,22 @@ fn aiur_fn_779( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66188,10 +66968,10 @@ fn aiur_fn_779( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66201,10 +66981,10 @@ fn aiur_fn_779( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66212,10 +66992,10 @@ fn aiur_fn_779( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66227,7 +67007,7 @@ fn aiur_fn_779( 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -66242,17 +67022,17 @@ fn aiur_fn_779( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -66267,22 +67047,22 @@ fn aiur_fn_779( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66290,10 +67070,10 @@ fn aiur_fn_779( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66301,7 +67081,7 @@ fn aiur_fn_779( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -66316,22 +67096,22 @@ fn aiur_fn_779( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66339,10 +67119,10 @@ fn aiur_fn_779( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66352,10 +67132,10 @@ fn aiur_fn_779( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -66363,10 +67143,10 @@ fn aiur_fn_779( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } diff --git a/crates/ixvm-codegen/src/aiur_ixvm_runner.rs b/crates/ixvm-codegen/src/aiur_ixvm_runner.rs index 325ad48c4..b7ac4647e 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm_runner.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm_runner.rs @@ -24,20 +24,23 @@ use aiur::execute::{ExecError, IOBuffer, QueryRecord}; /// Rust kernel. Deep recursion is handled via per-fn /// `stacker::maybe_grow` checks in the generated code — no /// pre-reserved giant stack on this thread, no scope dance. -// `args: Vec` mirrors `Toplevel::execute`'s signature so this fn -// can be used as an `impl Fn(&Toplevel, _, Vec, _) -> _` in -// `AiurSystem::prove_ixvm` — a `&[G]` here would break that bound. +// `args: Vec` mirrors `Toplevel::execute`'s signature so a +// `|t, f, a, io| execute_ixvm(t, f, a, io, false)` closure satisfies +// `AiurSystem::prove_ixvm`'s executor bound — a `&[G]` here would +// break it. `profile` enables per-entry virtual-span recording on the +// returned `QueryRecord` (see `aiur::querymap::QueryMap::finish`). #[allow(clippy::needless_pass_by_value)] pub fn execute_ixvm( toplevel: &Toplevel, fun_idx: FunIdx, args: Vec, io_buffer: &mut IOBuffer, + profile: bool, ) -> Result<(QueryRecord, Vec), ExecError> { if !toplevel.functions[fun_idx].entry { return Err(ExecError::NotEntryFunction(fun_idx)); } - let mut record = QueryRecord::new(toplevel); + let mut record = QueryRecord::new(toplevel, profile); let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?; Ok((record, output)) } diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 051a10e1a..7e8f5cf39 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -26,6 +26,7 @@ fn aiur_fn_0( unconstrained: bool, ) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -33,9 +34,9 @@ fn aiur_fn_0( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[0].weight(); } record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -43,14 +44,14 @@ 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_0] = { let __args: [G; IN_0] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_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 __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[0].weight(); } record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -67,6 +68,7 @@ fn aiur_fn_1( unconstrained: bool, ) -> Result<[G; OUT_1], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -93,13 +95,13 @@ fn aiur_fn_1( 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)); }; + if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -107,7 +109,7 @@ fn aiur_fn_1( _ => { 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)); }; + if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -115,7 +117,7 @@ fn aiur_fn_1( _ => { 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)); }; + if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -123,7 +125,7 @@ fn aiur_fn_1( _ => { 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)); }; + if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -131,7 +133,7 @@ fn aiur_fn_1( _ => { 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)); }; + if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -139,7 +141,7 @@ fn aiur_fn_1( _ => { 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)); }; + if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -147,7 +149,7 @@ fn aiur_fn_1( _ => { 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)); }; + if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -155,7 +157,7 @@ fn aiur_fn_1( _ => { 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)); }; + if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -172,6 +174,7 @@ fn aiur_fn_2( unconstrained: bool, ) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -194,7 +197,7 @@ fn aiur_fn_2( 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)); }; + if !unconstrained { record.virt += record.function_queries[2].weight(); } record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -209,6 +212,7 @@ fn aiur_fn_3( unconstrained: bool, ) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -241,7 +245,7 @@ fn aiur_fn_3( 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)); }; + if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -256,6 +260,7 @@ fn aiur_fn_4( unconstrained: bool, ) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -269,7 +274,7 @@ fn aiur_fn_4( 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)); }; + if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -284,12 +289,13 @@ fn aiur_fn_5( unconstrained: bool, ) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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)); }; + if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -304,12 +310,13 @@ fn aiur_fn_6( unconstrained: bool, ) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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)); }; + if !unconstrained { record.virt += record.function_queries[6].weight(); } record.function_queries[6].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -324,6 +331,7 @@ fn aiur_fn_7( unconstrained: bool, ) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -349,7 +357,7 @@ fn aiur_fn_7( 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)); }; + if !unconstrained { record.virt += record.function_queries[7].weight(); } record.function_queries[7].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -364,6 +372,7 @@ fn aiur_fn_8( unconstrained: bool, ) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -389,7 +398,7 @@ fn aiur_fn_8( 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)); }; + if !unconstrained { record.virt += record.function_queries[8].weight(); } record.function_queries[8].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -404,6 +413,7 @@ fn aiur_fn_9( unconstrained: bool, ) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -437,7 +447,7 @@ fn aiur_fn_9( 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)); }; + if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -451,7 +461,7 @@ fn aiur_fn_9( 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)); }; + if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -466,7 +476,7 @@ fn aiur_fn_9( 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)); }; + if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -480,7 +490,7 @@ fn aiur_fn_9( 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)); }; + if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -493,7 +503,7 @@ fn aiur_fn_9( 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)); }; + if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -505,7 +515,7 @@ fn aiur_fn_9( 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)); }; + if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -516,7 +526,7 @@ fn aiur_fn_9( 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)); }; + if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -526,7 +536,7 @@ fn aiur_fn_9( 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)); }; + if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -535,7 +545,7 @@ 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)); }; + if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -552,6 +562,7 @@ fn aiur_fn_10( unconstrained: bool, ) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -583,7 +594,7 @@ fn aiur_fn_10( 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)); }; + if !unconstrained { record.virt += record.function_queries[10].weight(); } record.function_queries[10].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -598,6 +609,7 @@ fn aiur_fn_11( unconstrained: bool, ) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -628,7 +640,7 @@ fn aiur_fn_11( 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)); }; + if !unconstrained { record.virt += record.function_queries[11].weight(); } record.function_queries[11].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -643,6 +655,7 @@ fn aiur_fn_12( unconstrained: bool, ) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -667,7 +680,7 @@ fn aiur_fn_12( 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)); }; + if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -682,6 +695,7 @@ fn aiur_fn_13( unconstrained: bool, ) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_1: G = G::from_u8(__gb[0]); @@ -740,7 +754,7 @@ fn aiur_fn_13( 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)); }; + if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -755,6 +769,7 @@ fn aiur_fn_14( unconstrained: bool, ) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = g_inverse_value(__v_0); let __v_2: G = (__v_0 * __v_1); @@ -771,7 +786,7 @@ fn aiur_fn_14( 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)); }; + if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -786,6 +801,7 @@ fn aiur_fn_15( unconstrained: bool, ) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -793,7 +809,7 @@ fn aiur_fn_15( 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)); }; + if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -808,6 +824,7 @@ fn aiur_fn_16( unconstrained: bool, ) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -815,7 +832,7 @@ fn aiur_fn_16( 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)); }; + if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -830,6 +847,7 @@ fn aiur_fn_17( unconstrained: bool, ) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); @@ -837,7 +855,7 @@ fn aiur_fn_17( 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)); }; + if !unconstrained { record.virt += record.function_queries[17].weight(); } record.function_queries[17].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -852,6 +870,7 @@ fn aiur_fn_18( unconstrained: bool, ) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -865,7 +884,7 @@ fn aiur_fn_18( 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)); }; + if !unconstrained { record.virt += record.function_queries[18].weight(); } record.function_queries[18].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -880,6 +899,7 @@ fn aiur_fn_19( unconstrained: bool, ) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = (__v_0 * __v_0); @@ -906,7 +926,7 @@ fn aiur_fn_19( 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)); }; + if !unconstrained { record.virt += record.function_queries[19].weight(); } record.function_queries[19].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -921,6 +941,7 @@ fn aiur_fn_20( unconstrained: bool, ) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -957,7 +978,7 @@ fn aiur_fn_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)); }; + if !unconstrained { record.virt += record.function_queries[20].weight(); } record.function_queries[20].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -972,6 +993,7 @@ fn aiur_fn_21( unconstrained: bool, ) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -982,7 +1004,7 @@ fn aiur_fn_21( 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)); }; + if !unconstrained { record.virt += record.function_queries[21].weight(); } record.function_queries[21].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -997,24 +1019,25 @@ fn aiur_fn_22( unconstrained: bool, ) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_22] = [__v_2, __v_3]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[22].weight(); } record.function_queries[22].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[22].weight(); } record.function_queries[22].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -1034,33 +1057,34 @@ fn aiur_fn_23( unconstrained: bool, ) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_22] = { let __args: [G; IN_22] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_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_22] = { let __args: [G; IN_22] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_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_22] = { let __args: [G; IN_22] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_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_22] = { let __args: [G; IN_22] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_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_22] = { let __args: [G; IN_22] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_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_22] = { let __args: [G; IN_22] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_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_22] = { let __args: [G; IN_22] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_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_22] = { let __args: [G; IN_22] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[23].weight(); } record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1075,8 +1099,9 @@ fn aiur_fn_24( unconstrained: bool, ) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[23].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[23].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -1086,10 +1111,10 @@ 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_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; let __hit = record.function_queries[10].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[10].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[10].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_10] = unsafe { *(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10]) }; __ret }, _ => aiur_fn_10(__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)); }; + if !unconstrained { record.virt += record.function_queries[24].weight(); } record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1104,6 +1129,7 @@ fn aiur_fn_25( unconstrained: bool, ) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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 }; @@ -1111,7 +1137,7 @@ fn aiur_fn_25( 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)); }; + if !unconstrained { record.virt += record.function_queries[25].weight(); } record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1126,6 +1152,7 @@ fn aiur_fn_26( unconstrained: bool, ) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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 }; @@ -1140,7 +1167,7 @@ fn aiur_fn_26( 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)); }; + if !unconstrained { record.virt += record.function_queries[26].weight(); } record.function_queries[26].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1155,8 +1182,9 @@ fn aiur_fn_27( unconstrained: bool, ) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = 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_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -1166,10 +1194,10 @@ 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_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; let __hit = record.function_queries[10].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[10].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[10].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_10] = unsafe { *(record.function_queries[10].output_at(__i).as_ptr() as *const [G; OUT_10]) }; __ret }, _ => aiur_fn_10(__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)); }; + if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1184,8 +1212,9 @@ fn aiur_fn_28( unconstrained: bool, ) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -1195,7 +1224,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_26] = { let __args: [G; IN_26] = [__v_9]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -1248,7 +1277,7 @@ fn aiur_fn_28( 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)); }; + if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1263,8 +1292,9 @@ fn aiur_fn_29( unconstrained: bool, ) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -1274,7 +1304,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_26] = { let __args: [G; IN_26] = [__v_9]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -1284,7 +1314,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_26] = { let __args: [G; IN_26] = [__v_18]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -1294,7 +1324,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_26] = { let __args: [G; IN_26] = [__v_27]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -1305,7 +1335,7 @@ fn aiur_fn_29( 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)); }; + if !unconstrained { record.virt += record.function_queries[29].weight(); } record.function_queries[29].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1320,15 +1350,16 @@ fn aiur_fn_30( unconstrained: bool, ) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_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_31] = { let __args: [G; IN_31] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[31].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[31].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[31].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => aiur_fn_31(__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)); }; + if !unconstrained { record.virt += record.function_queries[30].weight(); } record.function_queries[30].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1343,30 +1374,31 @@ fn aiur_fn_31( unconstrained: bool, ) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[31].weight(); } record.function_queries[31].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_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_31] = { let __args: [G; IN_31] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[31].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[31].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[31].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => aiur_fn_31(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[31].weight(); } record.function_queries[31].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1383,15 +1415,16 @@ fn aiur_fn_32( unconstrained: bool, ) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_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_33] = { let __args: [G; IN_33] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[32].weight(); } record.function_queries[32].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1406,19 +1439,20 @@ fn aiur_fn_33( unconstrained: bool, ) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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 __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -1430,13 +1464,13 @@ 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_33] = { let __args: [G; IN_33] = [__v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; let __v_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 __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1453,15 +1487,16 @@ fn aiur_fn_34( unconstrained: bool, ) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_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_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1476,19 +1511,20 @@ fn aiur_fn_35( unconstrained: bool, ) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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 __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[35].weight(); } record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -1498,7 +1534,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_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -1552,13 +1588,13 @@ 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_35] = { let __args: [G; IN_35] = [__v_19, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __v_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 __v_67: G = { let __values: [G; 4] = [__v_66, __v_40, __v_61, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[35].weight(); } record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1575,15 +1611,16 @@ fn aiur_fn_36( unconstrained: bool, ) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_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_37] = { let __args: [G; IN_37] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[36].weight(); } record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1598,19 +1635,20 @@ fn aiur_fn_37( unconstrained: bool, ) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[37].weight(); } record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -1620,7 +1658,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_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -1630,7 +1668,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_26] = { let __args: [G; IN_26] = [__v_19]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -1640,7 +1678,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_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -1652,14 +1690,14 @@ 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_37] = { let __args: [G; IN_37] = [__v_37, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; let __v_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 __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[37].weight(); } record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1676,15 +1714,16 @@ fn aiur_fn_38( unconstrained: bool, ) -> Result<[G; OUT_38], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[38].weight(); } record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1699,30 +1738,31 @@ fn aiur_fn_39( unconstrained: bool, ) -> Result<[G; OUT_39], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[39].weight(); } record.function_queries[39].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[32].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[32].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[32].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => 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 __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_39] = [__v_9, __v_7]; - if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[39].weight(); } record.function_queries[39].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1739,15 +1779,16 @@ fn aiur_fn_40( unconstrained: bool, ) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[41].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[41].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[41].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[40].weight(); } record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1762,30 +1803,31 @@ fn aiur_fn_41( unconstrained: bool, ) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[41].weight(); } record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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 __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[41].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[41].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[41].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => aiur_fn_41(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[41].weight(); } record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1802,15 +1844,16 @@ fn aiur_fn_42( unconstrained: bool, ) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_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 __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[43].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[43].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[43].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => aiur_fn_43(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[42].weight(); } record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1825,30 +1868,31 @@ fn aiur_fn_43( unconstrained: bool, ) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[43].weight(); } record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_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_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[40].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[43].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[43].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[43].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => aiur_fn_43(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[43].weight(); } record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1865,12 +1909,13 @@ fn aiur_fn_44( unconstrained: bool, ) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_44] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[44].weight(); } record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1885,15 +1930,16 @@ fn aiur_fn_45( unconstrained: bool, ) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_45] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[45].weight(); } record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1908,30 +1954,31 @@ fn aiur_fn_46( unconstrained: bool, ) -> Result<[G; OUT_46], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_46] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_46] = [__v_9, __v_7]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -1948,18 +1995,19 @@ fn aiur_fn_47( unconstrained: bool, ) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_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_36] = { let __args: [G; IN_36] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __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_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_47] = [__v_1, __v_3, __v_5, __v_6]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -1974,18 +2022,19 @@ fn aiur_fn_48( unconstrained: bool, ) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; let __v_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_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[48].weight(); } record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2000,15 +2049,16 @@ fn aiur_fn_49( unconstrained: bool, ) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_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_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[50].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_49] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[49].weight(); } record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2023,36 +2073,37 @@ fn aiur_fn_50( unconstrained: bool, ) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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 __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[50].weight(); } record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_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 __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; let __v_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_36] = { let __args: [G; IN_36] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[50].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_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 __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[50].weight(); } record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2069,18 +2120,19 @@ fn aiur_fn_51( unconstrained: bool, ) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_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_34] = { let __args: [G; IN_34] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_51] = [__v_1, __v_3, __v_5, __v_6]; - if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[51].weight(); } record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2095,15 +2147,16 @@ fn aiur_fn_52( unconstrained: bool, ) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_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_53] = { let __args: [G; IN_53] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[53].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[53].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[52].weight(); } record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2118,36 +2171,37 @@ fn aiur_fn_53( unconstrained: bool, ) -> Result<[G; OUT_53], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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 __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[53].weight(); } record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_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_34] = { let __args: [G; IN_34] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_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_36] = { let __args: [G; IN_36] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_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_53] = { let __args: [G; IN_53] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[53].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[53].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __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 __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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)); }; + if !unconstrained { record.virt += record.function_queries[53].weight(); } record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2164,21 +2218,22 @@ fn aiur_fn_54( unconstrained: bool, ) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_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_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[50].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_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_27] = { let __args: [G; IN_27] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_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_53] = { let __args: [G; IN_53] = [__v_6, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[53].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[53].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[54].weight(); } record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2193,15 +2248,16 @@ fn aiur_fn_55( unconstrained: bool, ) -> Result<[G; OUT_55], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_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_56] = { let __args: [G; IN_56] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[56].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[55].weight(); } record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2216,39 +2272,40 @@ fn aiur_fn_56( unconstrained: bool, ) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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 __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[56].weight(); } record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_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_50] = { let __args: [G; IN_50] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[50].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } }; let __v_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_27] = { let __args: [G; IN_27] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_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_53] = { let __args: [G; IN_53] = [__v_7, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[53].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[53].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => aiur_fn_53(__args, record, io_buffer, __cu)? } }; let __v_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_56] = { let __args: [G; IN_56] = [__v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[56].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_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 __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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)); }; + if !unconstrained { record.virt += record.function_queries[56].weight(); } record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2265,26 +2322,27 @@ fn aiur_fn_57( unconstrained: bool, ) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __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_32] = { let __args: [G; IN_32] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[32].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[32].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[32].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => aiur_fn_32(__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_27] = { let __args: [G; IN_27] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __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_56] = { let __args: [G; IN_56] = [__v_8, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[56].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_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_34] = { let __args: [G; IN_34] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_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_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; @@ -2295,7 +2353,7 @@ fn aiur_fn_57( 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)); }; + if !unconstrained { record.virt += record.function_queries[57].weight(); } record.function_queries[57].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2310,8 +2368,9 @@ fn aiur_fn_58( unconstrained: bool, ) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -2319,16 +2378,16 @@ fn aiur_fn_58( 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)); }; + if !unconstrained { record.virt += record.function_queries[58].weight(); } record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_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_42] = { let __args: [G; IN_42] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[58].weight(); } record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -2345,50 +2404,51 @@ fn aiur_fn_59( unconstrained: bool, ) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_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_31] = { let __args: [G; IN_31] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[31].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[31].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[31].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => aiur_fn_31(__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_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_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_36] = { let __args: [G; IN_36] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_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_36] = { let __args: [G; IN_36] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_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_34] = { let __args: [G; IN_34] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_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_27] = { let __args: [G; IN_27] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_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_31] = { let __args: [G; IN_31] = [__v_14, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[31].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[31].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[31].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => aiur_fn_31(__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_27] = { let __args: [G; IN_27] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_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_46] = { let __args: [G; IN_46] = [__v_18, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_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_32] = { let __args: [G; IN_32] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[32].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[32].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[32].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => aiur_fn_32(__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_27] = { let __args: [G; IN_27] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_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_56] = { let __args: [G; IN_56] = [__v_24, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[56].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_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_34] = { let __args: [G; IN_34] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_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_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -2398,21 +2458,21 @@ 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_42] = { let __args: [G; IN_42] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_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_58] = { let __args: [G; IN_58] = [__v_39]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; let __v_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_42] = { let __args: [G; IN_42] = [__v_42]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_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_42] = { let __args: [G; IN_42] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[59].weight(); } record.function_queries[59].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2427,6 +2487,7 @@ fn aiur_fn_60( unconstrained: bool, ) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2441,7 +2502,7 @@ fn aiur_fn_60( 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)); }; + if !unconstrained { record.virt += record.function_queries[60].weight(); } record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2456,6 +2517,7 @@ fn aiur_fn_61( unconstrained: bool, ) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2561,7 +2623,7 @@ fn aiur_fn_61( 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)); }; + if !unconstrained { record.virt += record.function_queries[61].weight(); } record.function_queries[61].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2576,6 +2638,7 @@ fn aiur_fn_62( unconstrained: bool, ) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); @@ -2611,7 +2674,7 @@ fn aiur_fn_62( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); @@ -2622,14 +2685,14 @@ fn aiur_fn_62( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); - let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_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_64] = { let __args: [G; IN_64] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[64].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[64].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -2663,7 +2726,7 @@ fn aiur_fn_62( 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)); }; + if !unconstrained { record.virt += record.function_queries[62].weight(); } record.function_queries[62].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -2678,6 +2741,7 @@ fn aiur_fn_63( unconstrained: bool, ) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -2712,7 +2776,7 @@ fn aiur_fn_63( let __v_31: G = inp[31]; let __v_32: G = inp[32]; let __v_33: G = inp[33]; - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -2751,12 +2815,12 @@ fn aiur_fn_63( 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)); }; + if !unconstrained { record.virt += record.function_queries[63].weight(); } record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); - let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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; let __hit = record.function_queries[63].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[63].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => aiur_fn_63(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; let __v_71: G = __r_arr[2]; @@ -2795,7 +2859,7 @@ fn aiur_fn_63( 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)); }; + if !unconstrained { record.virt += record.function_queries[63].weight(); } record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { @@ -2833,7 +2897,7 @@ fn aiur_fn_63( let __v_134: G = G::from_u64(205); let __v_135: G = G::from_u64(224); let __v_136: G = G::from_u64(91); - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; @@ -2904,7 +2968,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_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_205: G = __r_arr[0]; let __v_206: G = __r_arr[1]; let __v_207: G = __r_arr[2]; @@ -2940,9 +3004,9 @@ fn aiur_fn_63( let __v_237: G = G::from_u64(0); let __v_238: G = G::from_u64(0); let __v_239: G = G::from_u64(0); - let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[63].weight(); } record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -2978,7 +3042,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_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_203: G = __r_arr[0]; let __v_204: G = __r_arr[1]; let __v_205: G = __r_arr[2]; @@ -3014,9 +3078,9 @@ fn aiur_fn_63( let __v_235: G = G::from_u64(0); let __v_236: G = G::from_u64(0); let __v_237: G = G::from_u64(0); - let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[63].weight(); } record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -3043,8 +3107,9 @@ fn aiur_fn_64( unconstrained: bool, ) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -3081,7 +3146,7 @@ fn aiur_fn_64( let __v_34: G = __loaded[33]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; @@ -3119,12 +3184,12 @@ fn aiur_fn_64( 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)); }; + if !unconstrained { record.virt += record.function_queries[64].weight(); } record.function_queries[64].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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; let __hit = record.function_queries[63].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[63].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => aiur_fn_63(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __v_72: G = __r_arr[2]; @@ -3161,7 +3226,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_64] = { let __args: [G; IN_64] = [__v_103]; let __cu = unconstrained; let __hit = record.function_queries[64].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[64].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = __r_arr[2]; @@ -3195,13 +3260,13 @@ fn aiur_fn_64( 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)); }; + if !unconstrained { record.virt += record.function_queries[64].weight(); } record.function_queries[64].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_104: G = G::from_u64(0); - let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; + let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[64].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[64].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __r_arr[2]; @@ -3235,7 +3300,7 @@ fn aiur_fn_64( 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)); }; + if !unconstrained { record.virt += record.function_queries[64].weight(); } record.function_queries[64].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -3262,6 +3327,7 @@ fn aiur_fn_65( unconstrained: bool, ) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -3269,27 +3335,27 @@ fn aiur_fn_65( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[65].weight(); } record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; match __v_2.as_canonical_u64() { 63u64 => { - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[69].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[65].weight(); } record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -3297,10 +3363,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_65] = { let __args: [G; IN_65] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[65].weight(); } record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -3322,393 +3388,394 @@ fn aiur_fn_66( unconstrained: bool, ) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_97: G = __loaded[0]; let __v_98: G = __loaded[1]; let __v_99: G = __loaded[2]; match __v_97.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_100: G = __loaded[0]; let __v_101: G = __loaded[1]; let __v_102: G = __loaded[2]; match __v_100.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_127: G = __loaded[0]; let __v_128: G = __loaded[1]; let __v_129: G = __loaded[2]; match __v_127.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_130: G = __loaded[0]; let __v_131: G = __loaded[1]; let __v_132: G = __loaded[2]; match __v_130.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_133: G = __loaded[0]; let __v_134: G = __loaded[1]; let __v_135: G = __loaded[2]; match __v_133.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; match __v_136.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_139: G = __loaded[0]; let __v_140: G = __loaded[1]; let __v_141: G = __loaded[2]; match __v_139.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_142: G = __loaded[0]; let __v_143: G = __loaded[1]; let __v_144: G = __loaded[2]; match __v_142.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_145: G = __loaded[0]; let __v_146: G = __loaded[1]; let __v_147: G = __loaded[2]; match __v_145.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_148: G = __loaded[0]; let __v_149: G = __loaded[1]; let __v_150: G = __loaded[2]; match __v_148.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_151: G = __loaded[0]; let __v_152: G = __loaded[1]; let __v_153: G = __loaded[2]; match __v_151.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_154: G = __loaded[0]; let __v_155: G = __loaded[1]; let __v_156: G = __loaded[2]; match __v_154.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_157: G = __loaded[0]; let __v_158: G = __loaded[1]; let __v_159: G = __loaded[2]; match __v_157.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_160: G = __loaded[0]; let __v_161: G = __loaded[1]; let __v_162: G = __loaded[2]; match __v_160.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_163: G = __loaded[0]; let __v_164: G = __loaded[1]; let __v_165: G = __loaded[2]; match __v_163.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_166: G = __loaded[0]; let __v_167: G = __loaded[1]; let __v_168: G = __loaded[2]; match __v_166.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; match __v_169.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_172: G = __loaded[0]; let __v_173: G = __loaded[1]; let __v_174: G = __loaded[2]; match __v_172.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_175: G = __loaded[0]; let __v_176: G = __loaded[1]; let __v_177: G = __loaded[2]; match __v_175.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; match __v_178.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_181: G = __loaded[0]; let __v_182: G = __loaded[1]; let __v_183: G = __loaded[2]; match __v_181.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_184: G = __loaded[0]; let __v_185: G = __loaded[1]; let __v_186: G = __loaded[2]; match __v_184.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_187: G = __loaded[0]; let __v_188: G = __loaded[1]; let __v_189: G = __loaded[2]; match __v_187.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_190: G = __loaded[0]; let __v_191: G = __loaded[1]; let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_66] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; - if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -4043,24 +4110,25 @@ fn aiur_fn_67( unconstrained: bool, ) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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)); }; + if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -4077,6 +4145,7 @@ fn aiur_fn_68( unconstrained: bool, ) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -4090,7 +4159,7 @@ fn aiur_fn_68( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -4117,7 +4186,7 @@ fn aiur_fn_68( 0u64 => { let __v_17: G = (__v_6 + __v_7); let __v_18: G = (__v_8 + __v_17); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -4214,7 +4283,7 @@ fn aiur_fn_68( let __v_112: G = G::from_u64(0); let __v_113: G = G::from_u64(0); let __v_114: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; @@ -4248,7 +4317,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_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __v_150: G = __r_arr[2]; @@ -4281,70 +4350,70 @@ fn aiur_fn_68( let __v_177: G = __r_arr[29]; let __v_178: G = __r_arr[30]; let __v_179: G = __r_arr[31]; - let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_68] = [__v_5]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_68] = [__v_5]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_68] = [__v_5]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_68] = [__v_5]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_68] = [__v_5]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_68] = [__v_5]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_68] = [__v_5]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_68] = [__v_5]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -4377,15 +4446,15 @@ fn aiur_fn_68( let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; - let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -4394,7 +4463,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_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; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 * __v_8); let __v_19: G = (__v_2 - __v_1); @@ -4404,9 +4473,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_67] = { let __args: [G; IN_67] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; let __v_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_66] = { let __args: [G; IN_66] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[66].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -4471,7 +4540,7 @@ fn aiur_fn_68( let __v_88: G = __r_arr[61]; let __v_89: G = __r_arr[62]; let __v_90: G = __r_arr[63]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; @@ -4504,7 +4573,7 @@ fn aiur_fn_68( let __v_120: G = __loaded[29]; let __v_121: G = __loaded[30]; let __v_122: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_123: G = __loaded[0]; let __v_124: G = __loaded[1]; let __v_125: G = __loaded[2]; @@ -4537,7 +4606,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_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_155: G = __r_arr[0]; let __v_156: G = __r_arr[1]; let __v_157: G = __r_arr[2]; @@ -4570,9 +4639,9 @@ fn aiur_fn_68( let __v_184: G = __r_arr[29]; let __v_185: G = __r_arr[30]; let __v_186: G = __r_arr[31]; - let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -4589,6 +4658,7 @@ fn aiur_fn_69( unconstrained: bool, ) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -4598,7 +4668,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_66] = { let __args: [G; IN_66] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[66].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => aiur_fn_66(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -4665,9 +4735,9 @@ fn aiur_fn_69( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[193].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[193].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; let __v_75: G = __loaded[1]; let __v_76: G = __loaded[2]; @@ -4676,7 +4746,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_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; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = (__v_73 * __v_82); let __v_84: G = (__v_8 * __v_83); @@ -4713,7 +4783,7 @@ fn aiur_fn_69( let __v_115: G = G::from_u64(205); let __v_116: G = G::from_u64(224); let __v_117: G = G::from_u64(91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; @@ -4746,7 +4816,7 @@ fn aiur_fn_69( let __v_147: G = __loaded[29]; let __v_148: G = __loaded[30]; let __v_149: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_150: G = __loaded[0]; let __v_151: G = __loaded[1]; let __v_152: G = __loaded[2]; @@ -4780,7 +4850,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_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_183: G = __r_arr[0]; let __v_184: G = __r_arr[1]; let __v_185: G = __r_arr[2]; @@ -4813,13 +4883,13 @@ fn aiur_fn_69( let __v_212: G = __r_arr[29]; let __v_213: G = __r_arr[30]; let __v_214: G = __r_arr[31]; - let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_216: G = G::from_u64(1); let __v_217: G = G::from_u64(1); - let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_219: G = G::from_u64(0); let __v_220: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_221: G = __loaded[0]; let __v_222: G = __loaded[1]; let __v_223: G = __loaded[2]; @@ -4828,7 +4898,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_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; let __hit = record.function_queries[9].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[9].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[9].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_9] = unsafe { *(record.function_queries[9].output_at(__i).as_ptr() as *const [G; OUT_9]) }; __ret }, _ => aiur_fn_9(__args, record, io_buffer, __cu)? } }; let __v_229: G = __r_arr[0]; let __v_230: G = __r_arr[1]; let __v_231: G = __r_arr[2]; @@ -4837,21 +4907,21 @@ fn aiur_fn_69( let __v_234: G = __r_arr[5]; let __v_235: G = __r_arr[6]; let __v_236: G = __r_arr[7]; - let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[69].weight(); } record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[193].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[193].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_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_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[193].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[193].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; @@ -4860,7 +4930,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_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; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = (__v_84 * __v_8); let __v_86: G = (__v_75 * __v_85); @@ -4870,7 +4940,7 @@ fn aiur_fn_69( let __v_90: G = (__v_89 * __v_6); let __v_91: G = (__v_86 + __v_90); let __v_92: G = (__v_74 + __v_91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; @@ -4903,7 +4973,7 @@ fn aiur_fn_69( let __v_122: G = __loaded[29]; let __v_123: G = __loaded[30]; let __v_124: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_125: G = __loaded[0]; let __v_126: G = __loaded[1]; let __v_127: G = __loaded[2]; @@ -4936,7 +5006,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_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_157: G = __r_arr[0]; let __v_158: G = __r_arr[1]; let __v_159: G = __r_arr[2]; @@ -4971,15 +5041,15 @@ fn aiur_fn_69( let __v_188: G = __r_arr[31]; let __v_189: G = G::from_u64(1); let __v_190: G = G::from_u64(1); - let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_192: G = G::from_u64(0); let __v_193: G = G::from_u64(1); let __v_194: G = (__v_2 + __v_193); - let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[69].weight(); } record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -4996,6 +5066,7 @@ fn aiur_fn_70( unconstrained: bool, ) -> Result<[G; OUT_70], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -5125,7 +5196,7 @@ fn aiur_fn_70( 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)); }; + if !unconstrained { record.virt += record.function_queries[70].weight(); } record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -5140,6 +5211,7 @@ fn aiur_fn_71( unconstrained: bool, ) -> Result<[G; OUT_71], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -6101,7 +6173,7 @@ fn aiur_fn_71( 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)); }; + if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -6116,6 +6188,7 @@ fn aiur_fn_72( unconstrained: bool, ) -> Result<[G; OUT_72], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -6245,7 +6318,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_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = __r_arr[1]; let __v_131: G = __r_arr[2]; @@ -6279,7 +6352,7 @@ fn aiur_fn_72( 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)); }; + if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -6294,6 +6367,7 @@ fn aiur_fn_73( unconstrained: bool, ) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -6458,7 +6532,7 @@ fn aiur_fn_73( 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)); }; + if !unconstrained { record.virt += record.function_queries[73].weight(); } record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -7296,7 +7370,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_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_675: G = __r_arr[0]; let __v_676: G = __r_arr[1]; let __v_677: G = __r_arr[2]; @@ -7330,7 +7404,7 @@ fn aiur_fn_73( 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)); }; + if !unconstrained { record.virt += record.function_queries[73].weight(); } record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -7347,15 +7421,16 @@ fn aiur_fn_74( unconstrained: bool, ) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_74] = [__v_2, __v_3]; - if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[74].weight(); } record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -7375,12 +7450,13 @@ fn aiur_fn_75( unconstrained: bool, ) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[75].weight(); } record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -7395,18 +7471,19 @@ fn aiur_fn_76( unconstrained: bool, ) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[76].weight(); } record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -7421,11 +7498,12 @@ fn aiur_fn_77( unconstrained: bool, ) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); @@ -7438,7 +7516,7 @@ fn aiur_fn_77( 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)); }; + if !unconstrained { record.virt += record.function_queries[77].weight(); } record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -7453,17 +7531,18 @@ fn aiur_fn_78( unconstrained: bool, ) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(256); @@ -7480,7 +7559,7 @@ fn aiur_fn_78( 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)); }; + if !unconstrained { record.virt += record.function_queries[78].weight(); } record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -7495,33 +7574,34 @@ fn aiur_fn_79( unconstrained: bool, ) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __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_74] = { let __args: [G; IN_74] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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_74] = { let __args: [G; IN_74] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[79].weight(); } record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -7536,8 +7616,9 @@ fn aiur_fn_80( unconstrained: bool, ) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -7569,7 +7650,7 @@ fn aiur_fn_80( 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)); }; + if !unconstrained { record.virt += record.function_queries[80].weight(); } record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -7584,8 +7665,9 @@ fn aiur_fn_81( unconstrained: bool, ) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -7595,7 +7677,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_79] = { let __args: [G; IN_79] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -7605,7 +7687,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_79] = { let __args: [G; IN_79] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7615,7 +7697,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_79] = { let __args: [G; IN_79] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -7626,7 +7708,7 @@ fn aiur_fn_81( 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)); }; + if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -7641,19 +7723,20 @@ fn aiur_fn_82( unconstrained: bool, ) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -7663,7 +7746,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_79] = { let __args: [G; IN_79] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -7673,7 +7756,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_79] = { let __args: [G; IN_79] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -7683,7 +7766,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_79] = { let __args: [G; IN_79] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -7695,14 +7778,14 @@ 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_82] = { let __args: [G; IN_82] = [__v_37, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_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 __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -7719,298 +7802,299 @@ fn aiur_fn_83( unconstrained: bool, ) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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 __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_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_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = 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_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 3u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 5u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_76] = { let __args: [G; IN_76] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_76] = { let __args: [G; IN_76] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_76] = { let __args: [G; IN_76] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 11u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 12u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 13u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 14u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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 __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8029,30 +8113,31 @@ fn aiur_fn_84( unconstrained: bool, ) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[84].weight(); } record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_84] = { let __args: [G; IN_84] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[84].weight(); } record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8069,18 +8154,19 @@ fn aiur_fn_85( unconstrained: bool, ) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __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_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[85].weight(); } record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -8095,36 +8181,37 @@ fn aiur_fn_86( unconstrained: bool, ) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 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 __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_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_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); - let __v_13: G = { 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 __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_86] = [__v_13, __v_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)); }; + if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8141,6 +8228,7 @@ fn aiur_fn_87( unconstrained: bool, ) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -8148,7 +8236,7 @@ fn aiur_fn_87( 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)); }; + if !unconstrained { record.virt += record.function_queries[87].weight(); } record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -8159,11 +8247,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_87] = { let __args: [G; IN_87] = [__v_5, __v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[87].weight(); } record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -8171,10 +8259,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_87] = { let __args: [G; IN_87] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[87].weight(); } record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8193,8 +8281,9 @@ fn aiur_fn_88( unconstrained: bool, ) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_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_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -8205,7 +8294,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_77] = { let __args: [G; IN_77] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -8216,7 +8305,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_78] = { let __args: [G; IN_78] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -8227,7 +8316,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_77] = { let __args: [G; IN_77] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -8238,29 +8327,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_75] = { let __args: [G; IN_75] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_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_76] = { let __args: [G; IN_76] = [__v_42]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_44, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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_76] = { let __args: [G; IN_76] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_84] = { let __args: [G; IN_84] = [__v_48, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_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_76] = { let __args: [G; IN_76] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_86] = { let __args: [G; IN_86] = [__v_52, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_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_87] = { let __args: [G; IN_87] = [__v_51, __v_55, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_bool((__v_56 == G::ZERO)); let __v_58: G = (__v_56 + __v_57); @@ -8436,7 +8525,7 @@ fn aiur_fn_88( 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)); }; + if !unconstrained { record.virt += record.function_queries[88].weight(); } record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -8451,6 +8540,7 @@ fn aiur_fn_89( unconstrained: bool, ) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -8515,15 +8605,15 @@ fn aiur_fn_89( let __v_61: G = G::from_u64(0); let __v_62: G = G::from_u64(0); let __v_63: G = G::from_u64(0); - let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_65: G = { let __values: [G; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_69: G = { let __values: [G; 10] = [__v_58, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_68]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_70: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_65: G = { let __values: [G; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_69: G = { let __values: [G; 10] = [__v_58, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_68]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_70: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[89].weight(); } record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -8538,22 +8628,23 @@ fn aiur_fn_90( unconstrained: bool, ) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[90].weight(); } record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -8564,7 +8655,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_77] = { let __args: [G; IN_77] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -8575,7 +8666,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_78] = { let __args: [G; IN_78] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; @@ -8586,7 +8677,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_77] = { let __args: [G; IN_77] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; let __v_34: G = __r_arr[2]; @@ -8597,29 +8688,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_75] = { let __args: [G; IN_75] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } }; let __v_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_76] = { let __args: [G; IN_76] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_83] = { let __args: [G; IN_83] = [__v_45, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_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_76] = { let __args: [G; IN_76] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_84] = { let __args: [G; IN_84] = [__v_49, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; let __v_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_76] = { let __args: [G; IN_76] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_86] = { let __args: [G; IN_86] = [__v_53, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_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_87] = { let __args: [G; IN_87] = [__v_52, __v_56, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_bool((__v_57 == G::ZERO)); let __v_59: G = (__v_57 + __v_58); @@ -8796,12 +8887,12 @@ fn aiur_fn_90( } let __v_198: G = G::from_u64(1); let __v_199: G = (__v_1 - __v_198); - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_55, __v_199]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_55, __v_199]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[90].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; let __v_200: G = __r_arr[0]; let __v_201: G = __r_arr[1]; let __v_202: G = __r_arr[2]; let __v_203: G = G::from_u64(0); - let __v_204: G = { let __values: [G; 8] = [__v_203, __v_46, __v_44, __v_50, __v_32, __v_54, __v_42, __v_200]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_204: G = { let __values: [G; 8] = [__v_203, __v_46, __v_44, __v_50, __v_32, __v_54, __v_42, __v_200]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_205: G = G::from_u64(0); let __v_206: G = G::from_u64(0); let __v_207: G = G::from_u64(0); @@ -8809,15 +8900,15 @@ fn aiur_fn_90( let __v_209: G = G::from_u64(0); let __v_210: G = G::from_u64(0); let __v_211: G = G::from_u64(0); - let __v_212: G = { let __values: [G; 10] = [__v_211, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_201]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_213: G = { let __values: [G; 10] = [__v_210, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_212]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_214: G = { let __values: [G; 10] = [__v_209, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_213]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_215: G = { let __values: [G; 10] = [__v_208, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_214]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_216: G = { let __values: [G; 10] = [__v_207, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_215]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_217: G = { let __values: [G; 10] = [__v_206, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_216]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_218: G = { let __values: [G; 10] = [__v_205, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_217]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_212: G = { let __values: [G; 10] = [__v_211, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_201]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_213: G = { let __values: [G; 10] = [__v_210, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_212]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_214: G = { let __values: [G; 10] = [__v_209, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_213]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_215: G = { let __values: [G; 10] = [__v_208, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_214]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_216: G = { let __values: [G; 10] = [__v_207, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_215]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_217: G = { let __values: [G; 10] = [__v_206, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_216]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_218: G = { let __values: [G; 10] = [__v_205, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_217]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[90].weight(); } record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8834,8 +8925,9 @@ fn aiur_fn_91( unconstrained: bool, ) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -8843,19 +8935,19 @@ fn aiur_fn_91( 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)); }; + if !unconstrained { record.virt += record.function_queries[91].weight(); } record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_82] = { let __args: [G; IN_82] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[91].weight(); } record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8872,24 +8964,25 @@ fn aiur_fn_92( unconstrained: bool, ) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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 __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; let __v_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_92] = { let __args: [G; IN_92] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[92].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[92].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => aiur_fn_92(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_2.as_canonical_u64() { @@ -8897,17 +8990,17 @@ fn aiur_fn_92( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -8926,8 +9019,9 @@ fn aiur_fn_93( unconstrained: bool, ) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -8938,7 +9032,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_77] = { let __args: [G; IN_77] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -8949,7 +9043,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_77] = { let __args: [G; IN_77] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -8960,7 +9054,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_77] = { let __args: [G; IN_77] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -8971,7 +9065,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_77] = { let __args: [G; IN_77] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -8982,7 +9076,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_77] = { let __args: [G; IN_77] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -8993,7 +9087,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_77] = { let __args: [G; IN_77] = [__v_60]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -9013,16 +9107,16 @@ fn aiur_fn_93( let __v_77: G = G::from_u64(0); let __v_78: G = G::from_u64(1); let __v_79: G = G::from_u64(1); - let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -9037,8 +9131,9 @@ fn aiur_fn_94( unconstrained: bool, ) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; 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_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -9049,7 +9144,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_77] = { let __args: [G; IN_77] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -9060,7 +9155,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_77] = { let __args: [G; IN_77] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -9071,7 +9166,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_77] = { let __args: [G; IN_77] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -9082,7 +9177,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_77] = { let __args: [G; IN_77] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -9093,7 +9188,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_77] = { let __args: [G; IN_77] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -9104,7 +9199,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_77] = { let __args: [G; IN_77] = [__v_60]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -9124,15 +9219,15 @@ fn aiur_fn_94( let __v_77: G = G::from_u64(0); let __v_78: G = G::from_u64(1); let __v_79: G = G::from_u64(1); - let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_70]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; let __v_90: G = __r_arr[2]; @@ -9143,23 +9238,23 @@ 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_90] = { let __args: [G; IN_90] = [__v_97, __v_88]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[90].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; let __v_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_91] = { let __args: [G; IN_91] = [__v_100]; let __cu = unconstrained; let __hit = record.function_queries[91].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[91].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[91].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => aiur_fn_91(__args, record, io_buffer, __cu)? } }; let __v_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_92] = { let __args: [G; IN_92] = [__v_103, __v_88]; let __cu = unconstrained; let __hit = record.function_queries[92].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[92].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => aiur_fn_92(__args, record, io_buffer, __cu)? } }; let __v_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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_87, __v_107]; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[94].weight(); } record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -9174,6 +9269,7 @@ fn aiur_fn_95( unconstrained: bool, ) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -9183,12 +9279,12 @@ fn aiur_fn_95( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[95].weight(); } record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -9203,6 +9299,7 @@ fn aiur_fn_96( unconstrained: bool, ) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -9236,24 +9333,24 @@ 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_95] = { let __args: [G; IN_95] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[96].weight(); } record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -9268,6 +9365,7 @@ fn aiur_fn_97( unconstrained: bool, ) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -9301,7 +9399,7 @@ fn aiur_fn_97( 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)); }; + if !unconstrained { record.virt += record.function_queries[97].weight(); } record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -9316,6 +9414,7 @@ fn aiur_fn_98( unconstrained: bool, ) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(103); @@ -9350,7 +9449,7 @@ fn aiur_fn_98( let __v_31: G = G::from_u64(205); let __v_32: G = G::from_u64(224); let __v_33: G = G::from_u64(91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -9383,7 +9482,7 @@ fn aiur_fn_98( let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_66: G = __loaded[0]; let __v_67: G = __loaded[1]; let __v_68: G = __loaded[2]; @@ -9449,7 +9548,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_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = __r_arr[1]; let __v_133: G = __r_arr[2]; @@ -9482,9 +9581,9 @@ fn aiur_fn_98( let __v_160: G = __r_arr[29]; let __v_161: G = __r_arr[30]; let __v_162: G = __r_arr[31]; - let __v_163: G = { let __values: [G; 32] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_163: G = { let __values: [G; 32] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[98].weight(); } record.function_queries[98].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -9499,22 +9598,23 @@ fn aiur_fn_99( unconstrained: bool, ) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; 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_98] = { let __args: [G; IN_98] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[99].weight(); } record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __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)); }; + if !unconstrained { record.virt += record.function_queries[99].weight(); } record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -9531,9 +9631,10 @@ fn aiur_fn_100( unconstrained: bool, ) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -9541,7 +9642,7 @@ fn aiur_fn_100( 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)); }; + if !unconstrained { record.virt += record.function_queries[100].weight(); } record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -9551,14 +9652,14 @@ fn aiur_fn_100( 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)); }; + if !unconstrained { record.virt += record.function_queries[100].weight(); } record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[100].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[100].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[100].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[100].weight(); } record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -9580,10 +9681,11 @@ fn aiur_fn_101( unconstrained: bool, ) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -9591,13 +9693,13 @@ fn aiur_fn_101( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[101].weight(); } record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -9607,14 +9709,14 @@ fn aiur_fn_101( let __v_10: G = G::from_bool((__v_9 == G::ZERO)); match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[101].weight(); } record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -9627,19 +9729,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_101] = { let __args: [G; IN_101] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[101].weight(); } record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; let __v_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 __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[101].weight(); } record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -9668,9 +9770,10 @@ fn aiur_fn_102( unconstrained: bool, ) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -9762,11 +9865,11 @@ fn aiur_fn_102( } 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)); }; + if !unconstrained { record.virt += record.function_queries[102].weight(); } record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -9782,11 +9885,11 @@ fn aiur_fn_102( 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)); }; + if !unconstrained { record.virt += record.function_queries[102].weight(); } record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -9799,7 +9902,7 @@ fn aiur_fn_102( 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)); }; + if !unconstrained { record.virt += record.function_queries[102].weight(); } record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -9824,13 +9927,14 @@ fn aiur_fn_103( unconstrained: bool, ) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; @@ -9844,7 +9948,7 @@ fn aiur_fn_103( let __v_16: G = __r_arr[10]; match __v_16.as_canonical_u64() { 0u64 => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; @@ -9869,7 +9973,7 @@ fn aiur_fn_103( 0u64 => { match __v_24.as_canonical_u64() { 0u64 => { - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; @@ -9966,7 +10070,7 @@ fn aiur_fn_103( let __v_118: G = G::from_u64(0); let __v_119: G = G::from_u64(0); let __v_120: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; @@ -10001,7 +10105,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_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_155: G = __r_arr[0]; let __v_156: G = __r_arr[1]; let __v_157: G = __r_arr[2]; @@ -10034,69 +10138,69 @@ fn aiur_fn_103( let __v_184: G = __r_arr[29]; let __v_185: G = __r_arr[30]; let __v_186: G = __r_arr[31]; - let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_103] = [__v_5]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_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_102] = { let __args: [G; IN_102] = [__v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; @@ -10108,7 +10212,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_102] = { let __args: [G; IN_102] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -10120,7 +10224,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_102] = { let __args: [G; IN_102] = [__v_36, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -10132,7 +10236,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_102] = { let __args: [G; IN_102] = [__v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -10144,7 +10248,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_102] = { let __args: [G; IN_102] = [__v_58, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -10156,7 +10260,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_102] = { let __args: [G; IN_102] = [__v_69, __v_70]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; @@ -10168,7 +10272,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_102] = { let __args: [G; IN_102] = [__v_80, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = __r_arr[1]; let __v_85: G = __r_arr[2]; @@ -10189,7 +10293,7 @@ fn aiur_fn_103( let __v_100: G = (__v_27 + __v_99); let __v_101: G = (__v_16 + __v_100); let __v_102: G = (__v_94 * __v_101); - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; @@ -10202,7 +10306,7 @@ fn aiur_fn_103( let __v_112: G = __loaded[9]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_113: G = __loaded[0]; let __v_114: G = __loaded[1]; let __v_115: G = __loaded[2]; @@ -10231,7 +10335,7 @@ fn aiur_fn_103( let __v_118: G = (__v_113 * __v_116); let __v_119: G = (__v_116 - __v_118); let __v_120: G = (__v_113 + __v_119); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; @@ -10240,7 +10344,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_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; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = (__v_113 * __v_129); let __v_131: G = G::from_u64(2); @@ -10249,7 +10353,7 @@ fn aiur_fn_103( let __v_134: G = (__v_133 * __v_130); let __v_135: G = (__v_132 + __v_134); let __v_136: G = (__v_117 + __v_135); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; @@ -10282,7 +10386,7 @@ fn aiur_fn_103( let __v_166: G = __loaded[29]; let __v_167: G = __loaded[30]; let __v_168: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; @@ -10314,7 +10418,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_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_200: G = __r_arr[0]; let __v_201: G = __r_arr[1]; let __v_202: G = __r_arr[2]; @@ -10350,9 +10454,9 @@ fn aiur_fn_103( match __v_113.as_canonical_u64() { 1u64 => { let __v_232: G = G::from_u64(0); - let __v_233: G = { let __values: [G; 34] = [__v_232, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_233: G = { let __values: [G; 34] = [__v_232, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -10391,7 +10495,7 @@ fn aiur_fn_103( let __v_262: G = G::from_u64(224); let __v_263: G = G::from_u64(91); let __v_264: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_265: G = __loaded[0]; let __v_266: G = __loaded[1]; let __v_267: G = __loaded[2]; @@ -10400,7 +10504,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_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; let __hit = record.function_queries[9].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[9].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[9].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_9] = unsafe { *(record.function_queries[9].output_at(__i).as_ptr() as *const [G; OUT_9]) }; __ret }, _ => aiur_fn_9(__args, record, io_buffer, __cu)? } }; let __v_273: G = __r_arr[0]; let __v_274: G = __r_arr[1]; let __v_275: G = __r_arr[2]; @@ -10409,24 +10513,24 @@ fn aiur_fn_103( let __v_278: G = __r_arr[5]; let __v_279: G = __r_arr[6]; let __v_280: G = __r_arr[7]; - let __v_281: G = { let __values: [G; 8] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_282: G = { let __values: [G; 32] = [__v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_281: G = { let __values: [G; 8] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_282: G = { let __values: [G; 32] = [__v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_283: G = G::from_u64(0); - let __v_284: G = { let __values: [G; 34] = [__v_283, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __v_284: G = { let __values: [G; 34] = [__v_283, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[103].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_232: G = G::from_u64(1); let __v_233: G = (__v_2 + __v_232); - let __v_234: G = { let __values: [G; 32] = [__v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __v_234: G = { let __values: [G; 32] = [__v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[103].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -10447,6 +10551,7 @@ fn aiur_fn_104( unconstrained: bool, ) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); let __v_2: G = G::from_u64(230); @@ -10482,7 +10587,7 @@ fn aiur_fn_104( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); @@ -10492,14 +10597,14 @@ fn aiur_fn_104( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[103].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_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_64] = { let __args: [G; IN_64] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[64].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[64].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -10533,7 +10638,7 @@ fn aiur_fn_104( 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)); }; + if !unconstrained { record.virt += record.function_queries[104].weight(); } record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -10548,10 +10653,11 @@ fn aiur_fn_105( unconstrained: bool, ) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __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_101] = { let __args: [G; IN_101] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(103); let __v_5: G = G::from_u64(230); @@ -10587,7 +10693,7 @@ fn aiur_fn_105( let __v_35: G = G::from_u64(91); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); @@ -10597,14 +10703,14 @@ fn aiur_fn_105( let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __v_48: G = { let __values: [G; 8] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_49: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = { let __values: [G; 8] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_49: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_50: G = G::from_u64(1); let __v_51: G = G::from_u64(1); - let __v_52: G = { let __values: [G; 34] = [__v_50, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __v_52: G = { let __values: [G; 34] = [__v_50, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[103].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __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_64] = { let __args: [G; IN_64] = [__v_53]; let __cu = unconstrained; let __hit = record.function_queries[64].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[64].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -10637,9 +10743,9 @@ fn aiur_fn_105( let __v_83: G = __r_arr[29]; let __v_84: G = __r_arr[30]; let __v_85: G = __r_arr[31]; - let __v_86: G = { let __values: [G; 32] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_86: G = { let __values: [G; 32] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[105].weight(); } record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -10654,25 +10760,26 @@ fn aiur_fn_106( unconstrained: bool, ) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __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_100] = { let __args: [G; IN_100] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[100].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[100].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[100].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; 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)); }; + if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_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_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_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_98] = { let __args: [G; IN_98] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -10689,8 +10796,9 @@ fn aiur_fn_107( unconstrained: bool, ) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -10698,17 +10806,17 @@ fn aiur_fn_107( 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)); }; + if !unconstrained { record.virt += record.function_queries[107].weight(); } record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[107].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[107].weight(); } record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -10728,26 +10836,27 @@ fn aiur_fn_108( unconstrained: bool, ) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_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_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_107] = { let __args: [G; IN_107] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[107].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -10755,28 +10864,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_98] = { let __args: [G; IN_98] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __v_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_98] = { let __args: [G; IN_98] = [__v_7, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __v_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_100] = { let __args: [G; IN_100] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[100].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[100].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[100].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_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_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_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_98] = { let __args: [G; IN_98] = [__v_12, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; break '__mc_1 [__v_15]; }, @@ -10785,11 +10894,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_108] = { let __args: [G; IN_108] = [__v_14, __v_1, __v_2, __v_8, __v_11, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[108].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -10814,20 +10923,21 @@ fn aiur_fn_109( unconstrained: bool, ) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __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_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_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_108] = { let __args: [G; IN_108] = [__v_5, __v_0, __v_1, __v_3, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[108].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -10842,25 +10952,26 @@ fn aiur_fn_110( unconstrained: bool, ) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = 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_108] = { let __args: [G; IN_108] = [__v_6, __v_1, __v_2, __v_4, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[108].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[110].weight(); } record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -10875,25 +10986,26 @@ fn aiur_fn_111( unconstrained: bool, ) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -10913,9 +11025,10 @@ fn aiur_fn_112( unconstrained: bool, ) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -10923,23 +11036,23 @@ fn aiur_fn_112( 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)); }; + if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = (__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_112] = { let __args: [G; IN_112] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; 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)); }; + if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -10961,6 +11074,7 @@ fn aiur_fn_113( unconstrained: bool, ) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -10971,14 +11085,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_162] = { let __args: [G; IN_162] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_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_112] = { let __args: [G; IN_112] = [__v_10, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_15 + __v_15); let __v_17: G = (__v_4 + __v_6); @@ -11061,7 +11175,7 @@ fn aiur_fn_113( 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)); }; + if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -11076,21 +11190,22 @@ fn aiur_fn_114( unconstrained: bool, ) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = 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_162] = { let __args: [G; IN_162] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_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_112] = { let __args: [G; IN_112] = [__v_3, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__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)); }; + if !unconstrained { record.virt += record.function_queries[114].weight(); } record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -11105,6 +11220,7 @@ fn aiur_fn_115( unconstrained: bool, ) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -11113,7 +11229,7 @@ fn aiur_fn_115( 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 __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -11127,11 +11243,11 @@ fn aiur_fn_115( 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)); }; + if !unconstrained { record.virt += record.function_queries[115].weight(); } record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -11180,13 +11296,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_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; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[115].weight(); } record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11211,9 +11327,10 @@ fn aiur_fn_116( unconstrained: bool, ) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -11221,7 +11338,7 @@ fn aiur_fn_116( 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)); }; + if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -11337,14 +11454,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_116] = { let __args: [G; IN_116] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11364,25 +11481,26 @@ fn aiur_fn_117( unconstrained: bool, ) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[117].weight(); } record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_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_117] = { let __args: [G; IN_117] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_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_116] = { let __args: [G; IN_116] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[117].weight(); } record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11402,25 +11520,26 @@ fn aiur_fn_118( unconstrained: bool, ) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_118] = [__v_1]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[118].weight(); } record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_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_117] = { let __args: [G; IN_117] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[118].weight(); } record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11440,20 +11559,21 @@ fn aiur_fn_119( unconstrained: bool, ) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_119] = [__v_2]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_118] = { let __args: [G; IN_118] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11473,16 +11593,17 @@ fn aiur_fn_120( unconstrained: bool, ) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_120] = [__v_0]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[120].weight(); } record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -11494,12 +11615,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_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; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_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_120] = { let __args: [G; IN_120] = [__v_13, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[120].weight(); } record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11519,6 +11640,7 @@ fn aiur_fn_121( unconstrained: bool, ) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -11533,29 +11655,29 @@ fn aiur_fn_121( 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 __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[121].weight(); } record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_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; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_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_107] = { let __args: [G; IN_107] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[107].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[121].weight(); } record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -11572,11 +11694,12 @@ fn aiur_fn_122( unconstrained: bool, ) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -11584,13 +11707,13 @@ fn aiur_fn_122( 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 __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[122].weight(); } record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -11603,12 +11726,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_156] = { let __args: [G; IN_156] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_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_152] = { let __args: [G; IN_152] = [__v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -11627,7 +11750,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_122] = { let __args: [G; IN_122] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(0); @@ -11673,9 +11796,9 @@ fn aiur_fn_122( 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 __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[122].weight(); } record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11700,6 +11823,7 @@ fn aiur_fn_123( unconstrained: bool, ) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -11709,11 +11833,11 @@ fn aiur_fn_123( 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)); }; + if !unconstrained { record.virt += record.function_queries[123].weight(); } record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_192] = { let __args: [G; IN_192] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_1 - __v_4); let __v_7: G = (__v_5 + __v_6); @@ -11722,7 +11846,7 @@ fn aiur_fn_123( 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)); }; + if !unconstrained { record.virt += record.function_queries[123].weight(); } record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11730,10 +11854,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_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[123].weight(); } record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -11752,6 +11876,7 @@ fn aiur_fn_124( unconstrained: bool, ) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -11760,23 +11885,23 @@ fn aiur_fn_124( 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 __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[124].weight(); } record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; 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_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[124].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[124].weight(); } record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11787,11 +11912,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_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[124].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_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 __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[124].weight(); } record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -11810,6 +11935,7 @@ fn aiur_fn_125( unconstrained: bool, ) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -11818,7 +11944,7 @@ fn aiur_fn_125( 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 __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -11830,9 +11956,9 @@ fn aiur_fn_125( 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 __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[125].weight(); } record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -11844,7 +11970,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_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; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -11860,18 +11986,18 @@ fn aiur_fn_125( 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 __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[125].weight(); } record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_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; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_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 __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[125].weight(); } record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -11895,9 +12021,10 @@ fn aiur_fn_126( unconstrained: bool, ) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -11909,7 +12036,7 @@ fn aiur_fn_126( 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)); }; + if !unconstrained { record.virt += record.function_queries[126].weight(); } record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -11932,14 +12059,14 @@ fn aiur_fn_126( } 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)); }; + if !unconstrained { record.virt += record.function_queries[126].weight(); } record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_126] = { let __args: [G; IN_126] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[126].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[126].weight(); } record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -11963,19 +12090,20 @@ fn aiur_fn_127( unconstrained: bool, ) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; 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)); }; + if !unconstrained { record.virt += record.function_queries[127].weight(); } record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_127] = [__v_2]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[127].weight(); } record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -11995,6 +12123,7 @@ fn aiur_fn_128( unconstrained: bool, ) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12006,17 +12135,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_199] = { let __args: [G; IN_199] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_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_162] = { let __args: [G; IN_162] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __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_112] = { let __args: [G; IN_112] = [__v_13, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_12 * __v_18); let __v_20: G = G::from_u64(0); @@ -12045,9 +12174,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_201] = { let __args: [G; IN_201] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_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_196] = { let __args: [G; IN_196] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_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,10 +12184,10 @@ 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_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; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[128].weight(); } record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -12073,6 +12202,7 @@ fn aiur_fn_129( unconstrained: bool, ) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12085,12 +12215,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_192] = { let __args: [G; IN_192] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_162] = { let __args: [G; IN_162] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); let __v_17: G = (__v_5 * __v_15); @@ -12101,12 +12231,12 @@ 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_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; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_25, __v_3, __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_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; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[129].weight(); } record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -12121,6 +12251,7 @@ fn aiur_fn_130( unconstrained: bool, ) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12137,27 +12268,27 @@ fn aiur_fn_130( 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)); }; + if !unconstrained { record.virt += record.function_queries[130].weight(); } record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_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_192] = { let __args: [G; IN_192] = [__v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_9, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_10, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __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)); }; + if !unconstrained { record.virt += record.function_queries[130].weight(); } record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -12174,6 +12305,7 @@ fn aiur_fn_131( unconstrained: bool, ) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12190,30 +12322,30 @@ fn aiur_fn_131( 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)); }; + if !unconstrained { record.virt += record.function_queries[131].weight(); } record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_9, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_10, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[131].weight(); } record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -12230,6 +12362,7 @@ fn aiur_fn_132( unconstrained: bool, ) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12248,11 +12381,11 @@ fn aiur_fn_132( 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)); }; + if !unconstrained { record.virt += record.function_queries[132].weight(); } record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_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_194] = { let __args: [G; IN_194] = [__v_8, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -12261,21 +12394,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_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; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[132].weight(); } record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_192] = { let __args: [G; IN_192] = [__v_7, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_11, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_12, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_4 + __v_22); @@ -12283,10 +12416,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_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; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[132].weight(); } record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -12308,6 +12441,7 @@ fn aiur_fn_133( unconstrained: bool, ) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12326,24 +12460,24 @@ fn aiur_fn_133( 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)); }; + if !unconstrained { record.virt += record.function_queries[133].weight(); } record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_136] = { let __args: [G; IN_136] = [__v_6, __v_10, __v_5, __v_7, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[136].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_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_135] = { let __args: [G; IN_135] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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 +12486,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_199] = { let __args: [G; IN_199] = [__v_8, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_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_110] = { let __args: [G; IN_110] = [__v_2, __v_16, __v_19, __v_27, __v_17, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); if (__v_28 != __v_29) { @@ -12362,10 +12496,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_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; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[133].weight(); } record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -12387,6 +12521,7 @@ fn aiur_fn_134( unconstrained: bool, ) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12395,25 +12530,25 @@ fn aiur_fn_134( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[134].weight(); } record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __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_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_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 __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[134].weight(); } record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -12430,8 +12565,9 @@ fn aiur_fn_135( unconstrained: bool, ) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -12439,22 +12575,22 @@ fn aiur_fn_135( 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)); }; + if !unconstrained { record.virt += record.function_queries[135].weight(); } record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_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_135] = { let __args: [G; IN_135] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[135].weight(); } record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_135] = [__v_2]; - if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[135].weight(); } record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -12476,6 +12612,7 @@ fn aiur_fn_136( unconstrained: bool, ) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12485,13 +12622,13 @@ fn aiur_fn_136( 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 __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[136].weight(); } record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -12500,26 +12637,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_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[136].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[136].weight(); } record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_192] = { let __args: [G; IN_192] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[136].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_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 __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[136].weight(); } record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -12541,6 +12678,7 @@ fn aiur_fn_137( unconstrained: bool, ) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12549,12 +12687,12 @@ fn aiur_fn_137( 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)); }; + if !unconstrained { record.virt += record.function_queries[137].weight(); } record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __ret: [G; OUT_137] = [__v_3, __v_4, __v_1, __v_2]; - if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[137].weight(); } record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -12571,6 +12709,7 @@ fn aiur_fn_138( unconstrained: bool, ) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12805,13 +12944,13 @@ fn aiur_fn_138( } 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 __v_190: G = { let __values: [G; 10] = [__v_188, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_191: G = { let __values: [G; 10] = [__v_160, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_190]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_193: G = { let __values: [G; 10] = [__v_104, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_192]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_194: G = { let __values: [G; 10] = [__v_76, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_193]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[138].weight(); } record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -12826,13 +12965,14 @@ fn aiur_fn_139( unconstrained: bool, ) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __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 __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -12843,7 +12983,7 @@ fn aiur_fn_139( 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)); }; + if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -12854,7 +12994,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_161] = { let __args: [G; IN_161] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = (__v_16 * __v_10); @@ -12868,12 +13008,12 @@ fn aiur_fn_139( 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)); }; + if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -12897,6 +13037,7 @@ fn aiur_fn_140( unconstrained: bool, ) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -12906,7 +13047,7 @@ fn aiur_fn_140( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -12920,25 +13061,25 @@ 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_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[140].weight(); } record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -12946,7 +13087,7 @@ fn aiur_fn_140( 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; let __v_22: G = __loaded[1]; let __v_23: G = __loaded[2]; @@ -12955,7 +13096,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_194] = { let __args: [G; IN_194] = [__v_11, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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 +13204,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_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; let __hit = record.function_queries[113].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_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_139] = { let __args: [G; IN_139] = [__v_105, __v_106, __v_25, __v_15, __v_16, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[139].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[139].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_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_196] = { let __args: [G; IN_196] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; let __v_111: G = G::from_u64(1); if (__v_110 != __v_111) { @@ -13215,31 +13356,31 @@ fn aiur_fn_140( } 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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_230: G = { let __values: [G; 10] = [__v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_231: G = { let __values: [G; 10] = [__v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_232: G = 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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_236: G = G::from_u64(0); let __v_237: G = G::from_u64(1); let __v_238: G = G::from_u64(1); - let __v_239: G = { let __values: [G; 3] = [__v_237, __v_238, __v_238]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_240: G = { let __values: [G; 3] = [__v_236, __v_25, __v_239]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_19, __v_235, __v_240, __v_23, __v_12, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_240: G = { let __values: [G; 3] = [__v_236, __v_25, __v_239]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[140].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[140].weight(); } record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -13276,6 +13417,7 @@ fn aiur_fn_141( unconstrained: bool, ) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -13303,43 +13445,43 @@ 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_124] = { let __args: [G; IN_124] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[124].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_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_134] = { let __args: [G; IN_134] = [__v_15, __v_19, __v_18, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_1, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = 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_194] = { let __args: [G; IN_194] = [__v_1, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_1, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_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_126] = { let __args: [G; IN_126] = [__v_43, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[126].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_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 __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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_45: G = __loaded[0]; let __v_46: G = __loaded[1]; let __v_47: G = __loaded[2]; @@ -13351,14 +13493,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_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; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[140].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_23, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_195] = { let __args: [G; IN_195] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[195].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_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 +13508,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_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_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_127] = { let __args: [G; IN_127] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = (__v_62 + __v_63); let __v_65: G = (__v_61 - __v_64); @@ -13378,7 +13520,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_204] = { let __args: [G; IN_204] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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 +13528,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_110] = { let __args: [G; IN_110] = [__v_10, __v_29, __v_27, __v_0, __v_30, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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 +13542,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_110] = { let __args: [G; IN_110] = [__v_11, __v_34, __v_27, __v_0, __v_35, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_39]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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 +13556,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_110] = { let __args: [G; IN_110] = [__v_12, __v_39, __v_27, __v_0, __v_40, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = G::from_u64(1); if (__v_84 != __v_85) { @@ -13437,7 +13579,7 @@ fn aiur_fn_141( } 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)); }; + if !unconstrained { record.virt += record.function_queries[141].weight(); } record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -13467,6 +13609,7 @@ fn aiur_fn_142( unconstrained: bool, ) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -13492,7 +13635,7 @@ fn aiur_fn_142( 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; @@ -13501,20 +13644,20 @@ fn aiur_fn_142( 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)); }; + if !unconstrained { record.virt += record.function_queries[142].weight(); } record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_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_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[141].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[142].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[142].weight(); } record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -13534,6 +13677,7 @@ fn aiur_fn_143( unconstrained: bool, ) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -13567,17 +13711,17 @@ 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_204] = { let __args: [G; IN_204] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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 __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_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_118] = { let __args: [G; IN_118] = [__v_5, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; break '__mc_0 [__v_35]; }, @@ -13587,18 +13731,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_118] = { let __args: [G; IN_118] = [__v_3, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_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_118] = { let __args: [G; IN_118] = [__v_2, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_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_118] = { let __args: [G; IN_118] = [__v_1, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_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_198] = { let __args: [G; IN_198] = [__v_0, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_39, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = __r_arr[2]; @@ -13659,23 +13803,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_122] = { let __args: [G; IN_122] = [__v_59, __v_6, __v_7, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; let __v_104: G = __r_arr[1]; let __v_105: G = G::from_u64(1); let __v_106: G = G::from_u64(1); - let __v_107: G = { let __values: [G; 3] = [__v_105, __v_106, __v_106]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_107]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_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_198] = { let __args: [G; IN_198] = [__v_104, __v_108]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_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_120] = { let __args: [G; IN_120] = [__v_109, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_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_201] = { let __args: [G; IN_201] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_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 +13827,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_196] = { let __args: [G; IN_196] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_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 +13835,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_196] = { let __args: [G; IN_196] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_122: G = __r_arr[0]; let __v_123: G = G::from_u64(1); if (__v_122 != __v_123) { @@ -13703,10 +13847,10 @@ 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_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; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[142].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[143].weight(); } record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -13723,13 +13867,14 @@ fn aiur_fn_144( unconstrained: bool, ) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = 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)); }; + if !unconstrained { record.virt += record.function_queries[144].weight(); } record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -13744,8 +13889,9 @@ fn aiur_fn_145( unconstrained: bool, ) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -13754,11 +13900,11 @@ fn aiur_fn_145( 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)); }; + if !unconstrained { record.virt += record.function_queries[145].weight(); } record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -13769,14 +13915,14 @@ fn aiur_fn_145( 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)); }; + if !unconstrained { record.virt += record.function_queries[145].weight(); } record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[145].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[145].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __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)); }; + if !unconstrained { record.virt += record.function_queries[145].weight(); } record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -13798,6 +13944,7 @@ fn aiur_fn_146( unconstrained: bool, ) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -13815,16 +13962,16 @@ fn aiur_fn_146( 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 __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[146].weight(); } record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -13839,6 +13986,7 @@ fn aiur_fn_147( unconstrained: bool, ) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -13872,16 +14020,16 @@ 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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[147].weight(); } record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -13896,20 +14044,21 @@ fn aiur_fn_148( unconstrained: bool, ) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[148].weight(); } record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -13942,18 +14091,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_148] = { let __args: [G; IN_148] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[148].weight(); } record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -13973,16 +14122,17 @@ fn aiur_fn_149( unconstrained: bool, ) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[149].weight(); } record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -13993,12 +14143,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_149] = { let __args: [G; IN_149] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[149].weight(); } record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14018,9 +14168,10 @@ fn aiur_fn_150( unconstrained: bool, ) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -14060,7 +14211,7 @@ fn aiur_fn_150( 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_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); @@ -14071,14 +14222,14 @@ fn aiur_fn_150( 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_50: G = { let __values: [G; 8] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_51: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); - let __v_54: G = { let __values: [G; 34] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_39, __v_40, __v_41, __v_50, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_54: G = { let __values: [G; 34] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_39, __v_40, __v_41, __v_50, __v_51, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_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_64] = { let __args: [G; IN_64] = [__v_55]; let __cu = unconstrained; let __hit = record.function_queries[64].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[64].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -14113,78 +14264,78 @@ fn aiur_fn_150( let __v_87: G = __r_arr[31]; let __v_88: G = G::from_u64(1); let __v_89: G = G::from_u64(1); - let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_84, __v_85, __v_86, __v_87, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_84, __v_85, __v_86, __v_87, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_80, __v_81, __v_82, __v_83, __v_91]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_76, __v_77, __v_78, __v_79, __v_92]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_72, __v_73, __v_74, __v_75, __v_93]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_68, __v_69, __v_70, __v_71, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_64, __v_65, __v_66, __v_67, __v_95]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_60, __v_61, __v_62, __v_63, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_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_95] = { let __args: [G; IN_95] = [__v_56, __v_57, __v_58, __v_59, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __v_99: G = G::from_u64(1); let __v_100: G = G::from_u64(1); - let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_98, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_98, __v_101]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { let __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)); }; + if !unconstrained { record.virt += record.function_queries[150].weight(); } record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14228,50 +14379,50 @@ fn aiur_fn_150( } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; match __v_14.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; match __v_17.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; match __v_23.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[150].weight(); } record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14326,9 +14477,10 @@ fn aiur_fn_151( unconstrained: bool, ) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __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_150] = { let __args: [G; IN_150] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14357,11 +14509,11 @@ fn aiur_fn_151( 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)); }; + if !unconstrained { record.virt += record.function_queries[151].weight(); } record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[151].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -14373,7 +14525,7 @@ fn aiur_fn_151( 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)); }; + if !unconstrained { record.virt += record.function_queries[151].weight(); } record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -14390,9 +14542,10 @@ fn aiur_fn_152( unconstrained: bool, ) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __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_151] = { let __args: [G; IN_151] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[151].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14403,7 +14556,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_151] = { let __args: [G; IN_151] = [__v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[151].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -14415,7 +14568,7 @@ fn aiur_fn_152( 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)); }; + if !unconstrained { record.virt += record.function_queries[152].weight(); } record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -14430,19 +14583,20 @@ fn aiur_fn_153( unconstrained: bool, ) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[153].weight(); } record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -14451,11 +14605,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_153] = { let __args: [G; IN_153] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[153].weight(); } record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14477,10 +14631,11 @@ fn aiur_fn_154( unconstrained: bool, ) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __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_150] = { let __args: [G; IN_150] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -14529,19 +14684,19 @@ fn aiur_fn_154( let __v_44: G = __b1_out[7]; let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_153] = { let __args: [G; IN_153] = [__v_51, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[154].weight(); } record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -14556,6 +14711,7 @@ fn aiur_fn_155( unconstrained: bool, ) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -14567,13 +14723,13 @@ fn aiur_fn_155( let __v_8: G = inp[8]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_198] = { let __args: [G; IN_198] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[155].weight(); } record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -14588,17 +14744,18 @@ fn aiur_fn_156( unconstrained: bool, ) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_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_198] = { let __args: [G; IN_198] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[156].weight(); } record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -14613,6 +14770,7 @@ fn aiur_fn_157( unconstrained: bool, ) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(109); @@ -14642,22 +14800,22 @@ fn aiur_fn_157( 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 __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[157].weight(); } record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -14672,9 +14830,10 @@ fn aiur_fn_158( unconstrained: bool, ) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -14688,16 +14847,16 @@ fn aiur_fn_158( 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)); }; + if !unconstrained { record.virt += record.function_queries[158].weight(); } record.function_queries[158].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[158].weight(); } record.function_queries[158].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14717,20 +14876,21 @@ fn aiur_fn_159( unconstrained: bool, ) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; 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 __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[159].weight(); } record.function_queries[159].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[159].weight(); } record.function_queries[159].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -14750,6 +14910,7 @@ fn aiur_fn_160( unconstrained: bool, ) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -14759,15 +14920,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_149] = { let __args: [G; IN_149] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_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_148] = { let __args: [G; IN_148] = [__v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_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_148] = { let __args: [G; IN_148] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_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_149] = { let __args: [G; IN_149] = [__v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_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_158] = { let __args: [G; IN_158] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(109); @@ -14797,24 +14958,24 @@ fn aiur_fn_160( 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_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_38, __v_39, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_36, __v_37, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_34, __v_35, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_46: G = { let __values: [G; 3] = [__v_32, __v_33, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_30, __v_31, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_48: G = { let __values: [G; 3] = [__v_28, __v_29, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_26, __v_27, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_50: G = { let __values: [G; 3] = [__v_24, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_22, __v_23, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_20, __v_21, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_18, __v_19, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_16, __v_17, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_14, __v_15, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); - let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_55, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; @@ -14835,17 +14996,17 @@ fn aiur_fn_160( let __v_76: G = __r_arr[17]; let __v_77: G = G::from_u64(1); let __v_78: G = G::from_u64(1); - let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_198] = { let __args: [G; IN_198] = [__v_75, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = G::from_u64(1); let __v_84: G = G::from_u64(1); - let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_82, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_82, __v_85]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; let __v_87: G = __r_arr[1]; let __v_88: G = __r_arr[2]; @@ -14866,26 +15027,26 @@ fn aiur_fn_160( let __v_103: G = __r_arr[17]; let __v_104: G = G::from_u64(1); let __v_105: G = G::from_u64(1); - let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_198] = { let __args: [G; IN_198] = [__v_102, __v_108]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_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_156] = { let __args: [G; IN_156] = [__v_109, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; let __v_111: G = G::from_u64(1); let __v_112: G = G::from_u64(1); - let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_8, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_8, __v_113]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_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_198] = { let __args: [G; IN_198] = [__v_110, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = G::from_u64(1); let __v_117: G = G::from_u64(1); - let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_115, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_115, __v_118]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __v_121: G = __r_arr[2]; @@ -14904,12 +15065,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_156] = { let __args: [G; IN_156] = [__v_135, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = G::from_u64(1); let __v_139: G = G::from_u64(1); - let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_137, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_137, __v_140]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_141: G = __r_arr[0]; let __v_142: G = __r_arr[1]; let __v_143: G = __r_arr[2]; @@ -15097,7 +15258,7 @@ fn aiur_fn_160( 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)); }; + if !unconstrained { record.virt += record.function_queries[160].weight(); } record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -15112,13 +15273,14 @@ fn aiur_fn_161( unconstrained: bool, ) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; 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)); }; + if !unconstrained { record.virt += record.function_queries[161].weight(); } record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -15132,11 +15294,11 @@ 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_161] = { let __args: [G; IN_161] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __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)); }; + if !unconstrained { record.virt += record.function_queries[161].weight(); } record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -15153,28 +15315,29 @@ fn aiur_fn_162( unconstrained: bool, ) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; 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)); }; + if !unconstrained { record.virt += record.function_queries[162].weight(); } record.function_queries[162].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[162].weight(); } record.function_queries[162].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 + __v_1); - let __r_arr: [G; OUT_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_162] = { let __args: [G; IN_162] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[162].weight(); } record.function_queries[162].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -15191,10 +15354,11 @@ fn aiur_fn_163( unconstrained: bool, ) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __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_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); @@ -15202,7 +15366,7 @@ fn aiur_fn_163( 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)); }; + if !unconstrained { record.virt += record.function_queries[163].weight(); } record.function_queries[163].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -15217,23 +15381,24 @@ fn aiur_fn_164( unconstrained: bool, ) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; 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)); }; + if !unconstrained { record.virt += record.function_queries[164].weight(); } record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); let __v_3: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[164].weight(); } record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -15250,17 +15415,18 @@ fn aiur_fn_165( unconstrained: bool, ) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __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_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_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_162] = { let __args: [G; IN_162] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = g_inverse_value(__v_9); let __v_11: G = (__v_9 * __v_10); @@ -15372,7 +15538,7 @@ fn aiur_fn_165( 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)); }; + if !unconstrained { record.virt += record.function_queries[165].weight(); } record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -15387,6 +15553,7 @@ fn aiur_fn_166( unconstrained: bool, ) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -15412,29 +15579,29 @@ 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_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_145] = { let __args: [G; IN_145] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[145].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[145].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); if (__v_29 != __v_30) { @@ -15442,7 +15609,7 @@ fn aiur_fn_166( } 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)); }; + if !unconstrained { record.virt += record.function_queries[166].weight(); } record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -15459,6 +15626,7 @@ fn aiur_fn_167( unconstrained: bool, ) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -15476,7 +15644,7 @@ fn aiur_fn_167( 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)); }; + if !unconstrained { record.virt += record.function_queries[167].weight(); } record.function_queries[167].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -15491,6 +15659,7 @@ fn aiur_fn_168( unconstrained: bool, ) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -15508,7 +15677,7 @@ fn aiur_fn_168( 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)); }; + if !unconstrained { record.virt += record.function_queries[168].weight(); } record.function_queries[168].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -15523,8 +15692,9 @@ fn aiur_fn_169( unconstrained: bool, ) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -15533,13 +15703,13 @@ fn aiur_fn_169( 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 __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[169].weight(); } record.function_queries[169].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -15547,14 +15717,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_168] = { let __args: [G; IN_168] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[168].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_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_169] = { let __args: [G; IN_169] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_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 __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[169].weight(); } record.function_queries[169].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -15579,6 +15749,7 @@ fn aiur_fn_170( unconstrained: bool, ) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -15594,7 +15765,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_202] = { let __args: [G; IN_202] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[202].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -15603,7 +15774,7 @@ fn aiur_fn_170( 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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { @@ -15611,109 +15782,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_194] = { let __args: [G; IN_194] = [__v_4, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_194] = { let __args: [G; IN_194] = [__v_5, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_194] = { let __args: [G; IN_194] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_194] = { let __args: [G; IN_194] = [__v_3, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_194] = { let __args: [G; IN_194] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_194] = { let __args: [G; IN_194] = [__v_7, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_194] = { let __args: [G; IN_194] = [__v_8, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_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; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __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; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __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; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 * __v_21); @@ -15725,11 +15896,11 @@ fn aiur_fn_170( 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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_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; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = G::from_u64(0); @@ -15737,7 +15908,7 @@ fn aiur_fn_170( 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)); }; + if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -15757,6 +15928,7 @@ fn aiur_fn_171( unconstrained: bool, ) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -15776,28 +15948,28 @@ fn aiur_fn_171( 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[171].weight(); } record.function_queries[171].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_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; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_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_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[171].weight(); } record.function_queries[171].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -15817,6 +15989,7 @@ fn aiur_fn_172( unconstrained: bool, ) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -15872,7 +16045,7 @@ fn aiur_fn_172( 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)); }; + if !unconstrained { record.virt += record.function_queries[172].weight(); } record.function_queries[172].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -15887,6 +16060,7 @@ fn aiur_fn_173( unconstrained: bool, ) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -15906,7 +16080,7 @@ fn aiur_fn_173( 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -15917,27 +16091,27 @@ fn aiur_fn_173( 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)); }; + if !unconstrained { record.virt += record.function_queries[173].weight(); } record.function_queries[173].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_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_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; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[172].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[173].weight(); } record.function_queries[173].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -15957,6 +16131,7 @@ fn aiur_fn_174( unconstrained: bool, ) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -16001,7 +16176,7 @@ fn aiur_fn_174( 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; @@ -16009,13 +16184,13 @@ fn aiur_fn_174( 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)); }; + if !unconstrained { record.virt += record.function_queries[174].weight(); } record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_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; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -16024,10 +16199,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_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; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[172].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -16052,7 +16227,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_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; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[172].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = __r_arr[1]; let __v_84: G = __r_arr[2]; @@ -16063,23 +16238,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_194] = { let __args: [G; IN_194] = [__v_35, __v_89]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_35, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_36, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_36, __v_102]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; let __v_104: G = __r_arr[1]; let __v_105: G = (__v_103 + __v_20); @@ -16088,23 +16263,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_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; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[172].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_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_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_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_167] = { let __args: [G; IN_167] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[174].weight(); } record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -16113,44 +16288,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_194] = { let __args: [G; IN_194] = [__v_35, __v_91]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_35, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_35, __v_101]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_35, __v_106]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[172].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_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_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __v_121: G = (__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_167] = { let __args: [G; IN_167] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_123: G = __r_arr[0]; let __v_124: G = __r_arr[1]; let __v_125: G = G::from_u64(1); @@ -16165,11 +16340,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_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; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[174].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[174].weight(); } record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -16177,11 +16352,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_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; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[174].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[174].weight(); } record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -16207,6 +16382,7 @@ fn aiur_fn_175( unconstrained: bool, ) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -16237,7 +16413,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_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; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = G::from_u64(0); @@ -16286,7 +16462,7 @@ fn aiur_fn_175( 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_78: G = __loaded[0]; let __v_79: G = __loaded[1]; let __v_80: G = __loaded[2]; @@ -16294,42 +16470,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_194] = { let __args: [G; IN_194] = [__v_9, __v_82]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_8, __v_85]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_167] = { let __args: [G; IN_167] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_9, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_8, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_167] = { let __args: [G; IN_167] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[175].weight(); } record.function_queries[175].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(0); let __v_85: G = G::from_u64(1); @@ -16340,11 +16516,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_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; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[174].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[175].weight(); } record.function_queries[175].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -16364,6 +16540,7 @@ fn aiur_fn_176( unconstrained: bool, ) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -16390,17 +16567,17 @@ fn aiur_fn_176( 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 __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[176].weight(); } record.function_queries[176].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -16415,12 +16592,13 @@ fn aiur_fn_177( unconstrained: bool, ) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -16430,7 +16608,7 @@ fn aiur_fn_177( 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)); }; + if !unconstrained { record.virt += record.function_queries[177].weight(); } record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -16450,13 +16628,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_177] = { let __args: [G; IN_177] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[177].weight(); } record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -16476,120 +16654,121 @@ fn aiur_fn_178( unconstrained: bool, ) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_178] = [__v_1]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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)); }; + if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -16606,6 +16785,7 @@ fn aiur_fn_179( unconstrained: bool, ) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -16614,12 +16794,12 @@ fn aiur_fn_179( 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_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[179].weight(); } record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 1u64 => { @@ -16627,25 +16807,25 @@ fn aiur_fn_179( 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_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[179].weight(); } record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_192] = { let __args: [G; IN_192] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[179].weight(); } record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -16670,6 +16850,7 @@ fn aiur_fn_180( unconstrained: bool, ) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -16690,7 +16871,7 @@ fn aiur_fn_180( 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 __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -16703,46 +16884,46 @@ fn aiur_fn_180( 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)); }; + if !unconstrained { record.virt += record.function_queries[180].weight(); } record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_192] = { let __args: [G; IN_192] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_178] = { let __args: [G; IN_178] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[178].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_4, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_32, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_37, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_46: G = { let __values: [G; 4] = [__v_44, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_0 [__v_46, __v_49]; }, 1u64 => { @@ -16750,20 +16931,20 @@ fn aiur_fn_180( 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_46: G = { let __values: [G; 4] = [__v_44, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_0 [__v_46, __v_49]; }, 1u64 => { - let __r_arr: [G; OUT_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_192] = { let __args: [G; IN_192] = [__v_7, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_44, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; break '__mc_0 [__v_46, __v_48]; }, @@ -16779,14 +16960,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_161] = { let __args: [G; IN_161] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_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_162] = { let __args: [G; IN_162] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = g_inverse_value(__v_52); let __v_54: G = (__v_52 * __v_53); @@ -16915,18 +17096,18 @@ fn aiur_fn_180( let __v_153: G = G::from_u64(0); let __v_154: G = G::from_u64(1); let __v_155: G = G::from_u64(1); - let __v_156: G = { let __values: [G; 4] = [__v_154, __v_155, __v_155, __v_155]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_157: G = { let __values: [G; 4] = [__v_152, __v_31, __v_153, __v_156]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_158: G = { let __values: [G; 4] = [__v_150, __v_30, __v_151, __v_157]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_159: G = { let __values: [G; 4] = [__v_148, __v_11, __v_149, __v_158]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_160: G = { let __values: [G; 4] = [__v_146, __v_10, __v_147, __v_159]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_161: G = { let __values: [G; 4] = [__v_144, __v_15, __v_145, __v_160]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_156: G = { let __values: [G; 4] = [__v_154, __v_155, __v_155, __v_155]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_157: G = { let __values: [G; 4] = [__v_152, __v_31, __v_153, __v_156]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_158: G = { let __values: [G; 4] = [__v_150, __v_30, __v_151, __v_157]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_159: G = { let __values: [G; 4] = [__v_148, __v_11, __v_149, __v_158]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_160: G = { let __values: [G; 4] = [__v_146, __v_10, __v_147, __v_159]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_161: G = { let __values: [G; 4] = [__v_144, __v_15, __v_145, __v_160]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_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_162] = { let __args: [G; IN_162] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_166: G = __r_arr[0]; let __v_167: G = (__v_165 * __v_166); let __v_168: G = g_inverse_value(__v_167); @@ -16945,7 +17126,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_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; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_178: G = __r_arr[0]; let __v_179: G = __r_arr[1]; let __v_180: G = G::from_u64(0); @@ -16994,7 +17175,7 @@ fn aiur_fn_180( 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_226: G = __loaded[0]; let __v_227: G = __loaded[1]; let __v_228: G = __loaded[2]; @@ -17002,40 +17183,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_194] = { let __args: [G; IN_194] = [__v_41, __v_230]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_39, __v_233]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_167] = { let __args: [G; IN_167] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_41, __v_242]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_194] = { let __args: [G; IN_194] = [__v_39, __v_245]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_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_167] = { let __args: [G; IN_167] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_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_196] = { let __args: [G; IN_196] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_231: G = __r_arr[0]; let __v_232: G = G::from_u64(0); let __v_233: G = G::from_u64(1); @@ -17046,7 +17227,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_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; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[174].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_241: G = __r_arr[0]; let __v_242: G = __r_arr[1]; break '__mc_1 [__v_241, __v_242]; @@ -17058,19 +17239,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_192] = { let __args: [G; IN_192] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = { let __args: [G; IN_192] = [__v_232, __v_233]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_169] = { let __args: [G; IN_169] = [__v_234]; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_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_161] = { let __args: [G; IN_161] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_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_177] = { let __args: [G; IN_177] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_240: G = __r_arr[0]; let __v_241: G = __r_arr[1]; let __v_242: G = (__v_230 * __v_134); @@ -17087,7 +17268,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_196] = { let __args: [G; IN_196] = [__v_235]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_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 +17287,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_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; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[180].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[180].weight(); } record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -17131,10 +17312,11 @@ fn aiur_fn_181( unconstrained: bool, ) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -17150,7 +17332,7 @@ fn aiur_fn_181( 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)); }; + if !unconstrained { record.virt += record.function_queries[181].weight(); } record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -17176,7 +17358,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_181] = { let __args: [G; IN_181] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[181].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[181].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = (__v_0 * __v_35); @@ -17190,7 +17372,7 @@ fn aiur_fn_181( 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)); }; + if !unconstrained { record.virt += record.function_queries[181].weight(); } record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -17210,6 +17392,7 @@ fn aiur_fn_182( unconstrained: bool, ) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -17217,18 +17400,18 @@ fn aiur_fn_182( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = inp[6]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[182].weight(); } record.function_queries[182].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_181] = { let __args: [G; IN_181] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[181].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[181].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = (__v_3 + __v_10); @@ -17258,11 +17441,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_182] = { let __args: [G; IN_182] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[182].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __ret: [G; OUT_182] = [__v_33, __v_34]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[182].weight(); } record.function_queries[182].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -17282,6 +17465,7 @@ fn aiur_fn_183( unconstrained: bool, ) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -17325,9 +17509,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_185] = { let __args: [G; IN_185] = [__v_8, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_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_186] = { let __args: [G; IN_186] = [__v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[186].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; match __v_13.as_canonical_u64() { _ => { @@ -17335,7 +17519,7 @@ fn aiur_fn_183( 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 } }; + let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_0 [__v_41]; }, 1u64 => { @@ -17347,15 +17531,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_149] = { let __args: [G; IN_149] = [__v_17, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_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_148] = { let __args: [G; IN_148] = [__v_13, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_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_148] = { let __args: [G; IN_148] = [__v_39, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_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_149] = { let __args: [G; IN_149] = [__v_12, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_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_158] = { let __args: [G; IN_158] = [__v_7, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(109); @@ -17385,24 +17569,24 @@ fn aiur_fn_183( 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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_74: G = { 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_75: G = { let __values: [G; 3] = [__v_67, __v_68, __v_74]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_76: G = { let __values: [G; 3] = [__v_65, __v_66, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_77: G = { let __values: [G; 3] = [__v_63, __v_64, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_78: G = { let __values: [G; 3] = [__v_61, __v_62, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_79: G = { let __values: [G; 3] = [__v_59, __v_60, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_80: G = { let __values: [G; 3] = [__v_57, __v_58, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_81: G = { let __values: [G; 3] = [__v_55, __v_56, __v_80]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_82: G = { let __values: [G; 3] = [__v_53, __v_54, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_51, __v_52, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_84: G = { let __values: [G; 3] = [__v_49, __v_50, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_85: G = { let __values: [G; 3] = [__v_47, __v_48, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_86: G = { let __values: [G; 3] = [__v_45, __v_46, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_87: G = G::from_u64(1); let __v_88: G = G::from_u64(1); - let __v_89: G = { let __values: [G; 3] = [__v_87, __v_88, __v_88]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_86, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_86, __v_89]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; let __v_91: G = __r_arr[1]; let __v_92: G = __r_arr[2]; @@ -17423,17 +17607,17 @@ fn aiur_fn_183( let __v_107: G = __r_arr[17]; let __v_108: G = G::from_u64(1); let __v_109: G = G::from_u64(1); - let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_198] = { let __args: [G; IN_198] = [__v_106, __v_112]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = G::from_u64(1); let __v_115: G = G::from_u64(1); - let __v_116: G = { let __values: [G; 3] = [__v_114, __v_115, __v_115]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_113, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_113, __v_116]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_117: G = __r_arr[0]; let __v_118: G = __r_arr[1]; let __v_119: G = __r_arr[2]; @@ -17454,26 +17638,26 @@ fn aiur_fn_183( let __v_134: G = __r_arr[17]; let __v_135: G = G::from_u64(1); let __v_136: G = G::from_u64(1); - let __v_137: G = { let __values: [G; 3] = [__v_135, __v_136, __v_136]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_137]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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_198] = { let __args: [G; IN_198] = [__v_133, __v_139]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_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_156] = { let __args: [G; IN_156] = [__v_140, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_141: G = __r_arr[0]; let __v_142: G = G::from_u64(1); let __v_143: G = G::from_u64(1); - let __v_144: G = { let __values: [G; 3] = [__v_142, __v_143, __v_143]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_16, __v_144]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_16, __v_144]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_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_198] = { let __args: [G; IN_198] = [__v_141, __v_145]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_146: G = __r_arr[0]; let __v_147: G = G::from_u64(1); let __v_148: G = G::from_u64(1); - let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_146, __v_149]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_146, __v_149]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_150: G = __r_arr[0]; let __v_151: G = __r_arr[1]; let __v_152: G = __r_arr[2]; @@ -17492,12 +17676,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_156] = { let __args: [G; IN_156] = [__v_166, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_168: G = __r_arr[0]; let __v_169: G = G::from_u64(1); let __v_170: G = G::from_u64(1); - let __v_171: G = { let __values: [G; 3] = [__v_169, __v_170, __v_170]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_168, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_168, __v_171]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_172: G = __r_arr[0]; let __v_173: G = __r_arr[1]; let __v_174: G = __r_arr[2]; @@ -17686,27 +17870,27 @@ 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_182] = { let __args: [G; IN_182] = [__v_358, __v_359, __v_35, __v_210, __v_231, __v_252, __v_273]; let __cu = unconstrained; let __hit = record.function_queries[182].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[180].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_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_203] = { let __args: [G; IN_203] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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 __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_31.as_canonical_u64() { 0u64 => { 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_118] = { let __args: [G; IN_118] = [__v_32, __v_368]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_369: G = __r_arr[0]; break '__mc_1 [__v_369]; }, @@ -17716,18 +17900,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_118] = { let __args: [G; IN_118] = [__v_30, __v_369]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_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_118] = { let __args: [G; IN_118] = [__v_34, __v_370]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_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_118] = { let __args: [G; IN_118] = [__v_33, __v_371]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_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_198] = { let __args: [G; IN_198] = [__v_188, __v_372]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_373: G = __r_arr[0]; let __v_374: G = G::from_u64(1); let __v_375: G = G::from_u64(1); - let __v_376: G = { let __values: [G; 3] = [__v_374, __v_375, __v_375]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_373, __v_376]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_373, __v_376]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_377: G = __r_arr[0]; let __v_378: G = __r_arr[1]; let __v_379: G = __r_arr[2]; @@ -17788,31 +17972,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_122] = { let __args: [G; IN_122] = [__v_393, __v_18, __v_19, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_437: G = __r_arr[0]; let __v_438: G = __r_arr[1]; let __v_439: G = G::from_u64(1); let __v_440: G = G::from_u64(1); - let __v_441: G = { let __values: [G; 3] = [__v_439, __v_440, __v_440]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_21, __v_441]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_21, __v_441]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_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_198] = { let __args: [G; IN_198] = [__v_438, __v_442]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_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_120] = { let __args: [G; IN_120] = [__v_443, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_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_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; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_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_184] = { let __args: [G; IN_184] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[184].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[184].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_203] = { let __args: [G; IN_203] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_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 +18004,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_203] = { let __args: [G; IN_203] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_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_196] = { let __args: [G; IN_196] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_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 +18014,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_201] = { let __args: [G; IN_201] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_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 +18022,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_196] = { let __args: [G; IN_196] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_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 +18030,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_196] = { let __args: [G; IN_196] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_468: G = __r_arr[0]; let __v_469: G = G::from_u64(1); if (__v_468 != __v_469) { @@ -17858,10 +18042,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_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; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[142].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[183].weight(); } record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -17886,8 +18070,9 @@ fn aiur_fn_184( unconstrained: bool, ) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -17895,7 +18080,7 @@ fn aiur_fn_184( 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)); }; + if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { @@ -17906,10 +18091,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_184] = { let __args: [G; IN_184] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[184].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[184].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -17929,9 +18114,10 @@ fn aiur_fn_185( unconstrained: bool, ) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __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 __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -17944,13 +18130,13 @@ fn aiur_fn_185( 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 __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -17958,19 +18144,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_185] = { let __args: [G; IN_185] = [__v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_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_185] = { let __args: [G; IN_185] = [__v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_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 __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -17997,9 +18183,10 @@ fn aiur_fn_186( unconstrained: bool, ) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -18008,13 +18195,13 @@ fn aiur_fn_186( 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 __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -18022,19 +18209,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_186] = { let __args: [G; IN_186] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[186].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_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_186] = { let __args: [G; IN_186] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[186].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_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 __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -18061,15 +18248,16 @@ fn aiur_fn_187( unconstrained: bool, ) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_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_188] = { let __args: [G; IN_188] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[188].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __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)); }; + if !unconstrained { record.virt += record.function_queries[187].weight(); } record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18084,33 +18272,34 @@ fn aiur_fn_188( unconstrained: bool, ) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[188].weight(); } record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_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_190] = { let __args: [G; IN_190] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[190].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_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_188] = { let __args: [G; IN_188] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[188].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_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 __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[188].weight(); } record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -18127,15 +18316,16 @@ fn aiur_fn_189( unconstrained: bool, ) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_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_190] = { let __args: [G; IN_190] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[190].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_189] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[189].weight(); } record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -18150,19 +18340,20 @@ fn aiur_fn_190( unconstrained: bool, ) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; 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 __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[190].weight(); } record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[23].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[23].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -18174,13 +18365,13 @@ 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_190] = { let __args: [G; IN_190] = [__v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[190].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_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 __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[190].weight(); } record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, } @@ -18197,6 +18388,7 @@ fn aiur_fn_191( unconstrained: bool, ) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; @@ -18218,49 +18410,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_27] = { let __args: [G; IN_27] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_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_31] = { let __args: [G; IN_31] = [__v_21, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[31].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[31].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[31].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => aiur_fn_31(__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_36] = { let __args: [G; IN_36] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_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_36] = { let __args: [G; IN_36] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_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_36] = { let __args: [G; IN_36] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; let __v_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_34] = { let __args: [G; IN_34] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_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_27] = { let __args: [G; IN_27] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_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_31] = { let __args: [G; IN_31] = [__v_33, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[31].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[31].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[31].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_31] = unsafe { *(record.function_queries[31].output_at(__i).as_ptr() as *const [G; OUT_31]) }; __ret }, _ => aiur_fn_31(__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_27] = { let __args: [G; IN_27] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_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_46] = { let __args: [G; IN_46] = [__v_37, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; let __v_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_32] = { let __args: [G; IN_32] = [__v_39]; let __cu = unconstrained; let __hit = record.function_queries[32].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[32].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[32].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_32] = unsafe { *(record.function_queries[32].output_at(__i).as_ptr() as *const [G; OUT_32]) }; __ret }, _ => aiur_fn_32(__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_27] = { let __args: [G; IN_27] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; let __v_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_56] = { let __args: [G; IN_56] = [__v_43, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[56].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } }; let __v_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_34] = { let __args: [G; IN_34] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; let __v_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_26] = { let __args: [G; IN_26] = [__v_47]; let __cu = true; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -18270,17 +18462,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_42] = { let __args: [G; IN_42] = [__v_56]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_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_58] = { let __args: [G; IN_58] = [__v_58]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; let __v_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_42] = { let __args: [G; IN_42] = [__v_61]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_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_42] = { let __args: [G; IN_42] = [__v_63]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(1); @@ -18289,7 +18481,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_0] = { let __args: [G; IN_0] = [__v_70, __v_68, __v_69]; let __cu = true; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; let __v_72: G = G::from_u64(103); let __v_73: G = G::from_u64(230); @@ -18325,7 +18517,7 @@ fn aiur_fn_191( let __v_103: G = G::from_u64(91); let __v_104: G = G::from_u64(1); let __v_105: G = G::from_u64(1); - let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_107: G = G::from_u64(0); let __v_108: G = G::from_u64(0); let __v_109: G = G::from_u64(0); @@ -18336,14 +18528,14 @@ fn aiur_fn_191( let __v_114: G = G::from_u64(0); let __v_115: G = G::from_u64(0); let __v_116: G = G::from_u64(0); - let __v_117: G = { let __values: [G; 8] = [__v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_118: G = { let __values: [G; 32] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_117: G = { let __values: [G; 8] = [__v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_118: G = { let __values: [G; 32] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_119: G = G::from_u64(1); let __v_120: G = G::from_u64(1); - let __v_121: G = { let __values: [G; 34] = [__v_119, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_71, __v_106, __v_107, __v_108, __v_117, __v_118, __v_121]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_71, __v_106, __v_107, __v_108, __v_117, __v_118, __v_121]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_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_64] = { let __args: [G; IN_64] = [__v_122]; let __cu = unconstrained; let __hit = record.function_queries[64].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[64].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_123: G = __r_arr[0]; let __v_124: G = __r_arr[1]; let __v_125: G = __r_arr[2]; @@ -18376,7 +18568,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_77] = { let __args: [G; IN_77] = [__v_71]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_155: G = __r_arr[0]; let __v_156: G = __r_arr[1]; let __v_157: G = __r_arr[2]; @@ -18387,7 +18579,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_77] = { let __args: [G; IN_77] = [__v_164]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_165: G = __r_arr[0]; let __v_166: G = __r_arr[1]; let __v_167: G = __r_arr[2]; @@ -18398,7 +18590,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_77] = { let __args: [G; IN_77] = [__v_174]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_175: G = __r_arr[0]; let __v_176: G = __r_arr[1]; let __v_177: G = __r_arr[2]; @@ -18409,7 +18601,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_77] = { let __args: [G; IN_77] = [__v_184]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_185: G = __r_arr[0]; let __v_186: G = __r_arr[1]; let __v_187: G = __r_arr[2]; @@ -18420,7 +18612,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_77] = { let __args: [G; IN_77] = [__v_194]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_195: G = __r_arr[0]; let __v_196: G = __r_arr[1]; let __v_197: G = __r_arr[2]; @@ -18431,7 +18623,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_77] = { let __args: [G; IN_77] = [__v_204]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_205: G = __r_arr[0]; let __v_206: G = __r_arr[1]; let __v_207: G = __r_arr[2]; @@ -18442,7 +18634,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_77] = { let __args: [G; IN_77] = [__v_214]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_215: G = __r_arr[0]; let __v_216: G = __r_arr[1]; let __v_217: G = __r_arr[2]; @@ -18462,15 +18654,15 @@ fn aiur_fn_191( let __v_231: G = G::from_u64(0); let __v_232: G = G::from_u64(1); let __v_233: G = G::from_u64(1); - let __v_234: G = { let __values: [G; 10] = [__v_232, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_235: G = { let __values: [G; 10] = [__v_231, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_234]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_236: G = { let __values: [G; 10] = [__v_230, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_235]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_237: G = { let __values: [G; 10] = [__v_229, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_236]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_238: G = { let __values: [G; 10] = [__v_228, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_237]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_239: G = { let __values: [G; 10] = [__v_227, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_238]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_240: G = { let __values: [G; 10] = [__v_226, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_239]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_241: G = { let __values: [G; 10] = [__v_225, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_240]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_224]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __v_234: G = { let __values: [G; 10] = [__v_232, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_235: G = { let __values: [G; 10] = [__v_231, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_234]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_236: G = { let __values: [G; 10] = [__v_230, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_235]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_237: G = { let __values: [G; 10] = [__v_229, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_236]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_238: G = { let __values: [G; 10] = [__v_228, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_237]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_239: G = { let __values: [G; 10] = [__v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_240: G = { let __values: [G; 10] = [__v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_241: G = { let __values: [G; 10] = [__v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_224]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; let __v_242: G = __r_arr[0]; let __v_243: G = __r_arr[1]; let __v_244: G = __r_arr[2]; @@ -18481,20 +18673,20 @@ 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_90] = { let __args: [G; IN_90] = [__v_251, __v_242]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[90].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; let __v_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_91] = { let __args: [G; IN_91] = [__v_254]; let __cu = unconstrained; let __hit = record.function_queries[91].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[91].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[91].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => aiur_fn_91(__args, record, io_buffer, __cu)? } }; let __v_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_92] = { let __args: [G; IN_92] = [__v_257, __v_242]; let __cu = unconstrained; let __hit = record.function_queries[92].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[92].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => aiur_fn_92(__args, record, io_buffer, __cu)? } }; let __v_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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_241, __v_261]; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; let __v_263: G = G::from_u64(2); let __v_264: G = G::from_u64(0); @@ -18502,7 +18694,7 @@ fn aiur_fn_191( 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 __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_267, __v_265, __v_266]; let __cu = true; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_268: G = __r_arr[0]; let __v_269: G = G::from_u64(103); let __v_270: G = G::from_u64(230); @@ -18538,7 +18730,7 @@ fn aiur_fn_191( let __v_300: G = G::from_u64(91); let __v_301: G = G::from_u64(1); let __v_302: G = G::from_u64(1); - let __v_303: G = { let __values: [G; 3] = [__v_301, __v_302, __v_302]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_304: G = G::from_u64(0); let __v_305: G = G::from_u64(0); let __v_306: G = G::from_u64(0); @@ -18549,14 +18741,14 @@ fn aiur_fn_191( let __v_311: G = G::from_u64(0); let __v_312: G = G::from_u64(0); let __v_313: G = G::from_u64(0); - let __v_314: G = { let __values: [G; 8] = [__v_306, __v_307, __v_308, __v_309, __v_310, __v_311, __v_312, __v_313]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_315: G = { let __values: [G; 32] = [__v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_268, __v_303, __v_304, __v_305, __v_314, __v_315, __v_318]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_319]; let __cu = unconstrained; let __hit = record.function_queries[64].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[64].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => aiur_fn_64(__args, record, io_buffer, __cu)? } }; let __v_320: G = __r_arr[0]; let __v_321: G = __r_arr[1]; let __v_322: G = __r_arr[2]; @@ -18589,37 +18781,37 @@ fn aiur_fn_191( 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 __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_268]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_353, __v_352]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[188].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_354: G = __r_arr[0]; let __v_355: 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 __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_62]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_64]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_57]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[145].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[145].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_362: G = __r_arr[0]; let __v_363: G = G::from_u64(1); if (__v_362 != __v_363) { @@ -18637,9 +18829,9 @@ fn aiur_fn_191( _ => { 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 __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_252, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_258, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[186].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_358: G = __r_arr[0]; match __v_24.as_canonical_u64() { _ => { @@ -18647,7 +18839,7 @@ fn aiur_fn_191( 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 } }; + 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; break '__mc_2 [__v_361]; }, 1u64 => { @@ -18659,15 +18851,15 @@ 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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_34, __v_268]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_24, __v_360]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_359, __v_361]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_22, __v_362]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_262, __v_363]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_364: G = __r_arr[0]; let __v_365: G = G::from_u64(0); let __v_366: G = G::from_u64(109); @@ -18697,24 +18889,24 @@ fn aiur_fn_191( 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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_406, __v_409]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_410: G = __r_arr[0]; let __v_411: G = __r_arr[1]; let __v_412: G = __r_arr[2]; @@ -18735,17 +18927,17 @@ fn aiur_fn_191( 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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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 __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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_426, __v_432]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_433, __v_436]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_437: G = __r_arr[0]; let __v_438: G = __r_arr[1]; let __v_439: G = __r_arr[2]; @@ -18766,26 +18958,26 @@ fn aiur_fn_191( let __v_454: G = __r_arr[17]; let __v_455: G = G::from_u64(1); let __v_456: G = G::from_u64(1); - let __v_457: G = { let __values: [G; 3] = [__v_455, __v_456, __v_456]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_445, __v_446, __v_447, __v_448, __v_449, __v_450, __v_451, __v_452, __v_457]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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 __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; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_453, __v_459]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_460, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_30, __v_464]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_461, __v_465]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_466, __v_469]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_470: G = __r_arr[0]; let __v_471: G = __r_arr[1]; let __v_472: G = __r_arr[2]; @@ -18804,12 +18996,12 @@ fn aiur_fn_191( 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 __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_486, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_488, __v_491]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_492: G = __r_arr[0]; let __v_493: G = __r_arr[1]; let __v_494: G = __r_arr[2]; @@ -18998,27 +19190,27 @@ fn aiur_fn_191( 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 __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; let __hit = record.function_queries[182].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_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 __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; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[180].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_357]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_684: 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 __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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 __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_59.as_canonical_u64() { 0u64 => { break '__mc_3 [__v_688]; }, 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 __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_60, __v_688]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_689: G = __r_arr[0]; break '__mc_3 [__v_689]; }, @@ -19028,18 +19220,18 @@ fn aiur_fn_191( } }; 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 __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_57, __v_689]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_64, __v_690]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_62, __v_691]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_508, __v_692]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_693, __v_696]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_697: G = __r_arr[0]; let __v_698: G = __r_arr[1]; let __v_699: G = __r_arr[2]; @@ -19100,31 +19292,31 @@ fn aiur_fn_191( 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_713, __v_38, __v_40, __v_205]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_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_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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_46, __v_761]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_758, __v_762]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_763, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_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 __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; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[184].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[184].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_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 __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_204] = { let __args: [G; IN_204] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_252]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_771: G = __r_arr[0]; let __v_772: G = (__v_770 - __v_771); let __v_773: G = G::from_bool((__v_772 == G::ZERO)); @@ -19132,9 +19324,9 @@ fn aiur_fn_191( 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_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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_357]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_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 __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_776: G = __r_arr[0]; let __v_777: G = (__v_775 - __v_776); let __v_778: G = G::from_bool((__v_777 == G::ZERO)); @@ -19142,7 +19334,7 @@ fn aiur_fn_191( 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_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_201] = { let __args: [G; IN_201] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_780: G = __r_arr[0]; let __v_781: G = (__v_780 - __v_685); let __v_782: G = G::from_bool((__v_781 == G::ZERO)); @@ -19150,7 +19342,7 @@ fn aiur_fn_191( 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_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 __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_784: G = __r_arr[0]; let __v_785: G = (__v_784 - __v_195); let __v_786: G = G::from_bool((__v_785 == G::ZERO)); @@ -19158,7 +19350,7 @@ fn aiur_fn_191( 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_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 __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_788: G = __r_arr[0]; let __v_789: G = G::from_u64(1); if (__v_788 != __v_789) { @@ -19170,7 +19362,7 @@ fn aiur_fn_191( if (__v_791 != __v_792) { return Err(ExecError::AssertEqMismatch { lhs: __v_791.as_canonical_u64(), rhs: __v_792.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_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 __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; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[142].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_793: G = __r_arr[0]; break '__mc_1 [__v_793]; }, @@ -19285,7 +19477,7 @@ fn aiur_fn_191( if (__v_430 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_430.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_259.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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]; @@ -19396,7 +19588,7 @@ fn aiur_fn_191( 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 __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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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]; @@ -19420,7 +19612,7 @@ fn aiur_fn_191( 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)); }; + if !unconstrained { record.virt += record.function_queries[191].weight(); } record.function_queries[191].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) } @@ -19435,18 +19627,19 @@ fn aiur_fn_192( unconstrained: bool, ) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __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_199] = { let __args: [G; IN_199] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_192] = [__v_4]; - if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[192].weight(); } record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19466,8 +19659,9 @@ fn aiur_fn_193( unconstrained: bool, ) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -19475,13 +19669,13 @@ fn aiur_fn_193( 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)); }; + if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_193] = [__v_4]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19501,11 +19695,12 @@ fn aiur_fn_194( unconstrained: bool, ) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __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_205] = { let __args: [G; IN_205] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[205].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[205].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -19513,7 +19708,7 @@ fn aiur_fn_194( 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)); }; + if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19533,8 +19728,9 @@ fn aiur_fn_195( unconstrained: bool, ) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -19544,16 +19740,16 @@ fn aiur_fn_195( 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)); }; + if !unconstrained { record.virt += record.function_queries[195].weight(); } record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[195].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[195].weight(); } record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19573,8 +19769,9 @@ fn aiur_fn_196( unconstrained: bool, ) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -19583,16 +19780,16 @@ fn aiur_fn_196( 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)); }; + if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __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_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19612,9 +19809,10 @@ fn aiur_fn_197( unconstrained: bool, ) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -19628,16 +19826,16 @@ fn aiur_fn_197( 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)); }; + if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __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_197] = { let __args: [G; IN_197] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_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 __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19657,25 +19855,26 @@ fn aiur_fn_198( unconstrained: bool, ) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __ret: [G; OUT_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)); }; + if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19695,27 +19894,28 @@ fn aiur_fn_199( unconstrained: bool, ) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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)); }; + if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_199] = [__v_7]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19737,8 +19937,9 @@ fn aiur_fn_200( unconstrained: bool, ) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -19750,16 +19951,16 @@ fn aiur_fn_200( 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)); }; + if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __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_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19779,8 +19980,9 @@ fn aiur_fn_201( unconstrained: bool, ) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -19795,16 +19997,16 @@ fn aiur_fn_201( 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)); }; + if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_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_201] = { let __args: [G; IN_201] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19824,11 +20026,12 @@ fn aiur_fn_202( unconstrained: bool, ) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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_206] = { let __args: [G; IN_206] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -19838,7 +20041,7 @@ fn aiur_fn_202( 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)); }; + if !unconstrained { record.virt += record.function_queries[202].weight(); } record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19858,8 +20061,9 @@ fn aiur_fn_203( unconstrained: bool, ) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __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 __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -19872,16 +20076,16 @@ fn aiur_fn_203( 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)); }; + if !unconstrained { record.virt += record.function_queries[203].weight(); } record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_203] = { let __args: [G; IN_203] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[203].weight(); } record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19901,8 +20105,9 @@ fn aiur_fn_204( unconstrained: bool, ) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -19910,16 +20115,16 @@ fn aiur_fn_204( 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)); }; + if !unconstrained { record.virt += record.function_queries[204].weight(); } record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); 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_204] = { let __args: [G; IN_204] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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)); }; + if !unconstrained { record.virt += record.function_queries[204].weight(); } record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19939,20 +20144,21 @@ fn aiur_fn_205( unconstrained: bool, ) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __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)); }; + if !unconstrained { record.virt += record.function_queries[205].weight(); } record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[205].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[205].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -19960,7 +20166,7 @@ fn aiur_fn_205( 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)); }; + if !unconstrained { record.virt += record.function_queries[205].weight(); } record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { @@ -19982,20 +20188,21 @@ fn aiur_fn_206( unconstrained: bool, ) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __vsnap = record.virt; let __v_0: G = inp[0]; let __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)); }; + if !unconstrained { record.virt += record.function_queries[206].weight(); } record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -20005,7 +20212,7 @@ fn aiur_fn_206( 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)); }; + if !unconstrained { record.virt += record.function_queries[206].weight(); } record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, _ => { diff --git a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs index 720fce56f..1fddef667 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs @@ -41,7 +41,8 @@ pub fn execute_multi_stark( if !toplevel.functions[fun_idx].entry { return Err(ExecError::NotEntryFunction(fun_idx)); } - let mut record = QueryRecord::new(toplevel); + // The recursive verifier is never profiled. + let mut record = QueryRecord::new(toplevel, false); let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?; Ok((record, output)) } From 1639996f50a3c0c5ba4775fca499a294cf3f62d8 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Fri, 28 Aug 2026 15:38:47 +0000 Subject: [PATCH 06/44] aiur: batch weights; budget-gated proves that split in place MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Per-constant weights come out of the rayon shard batch without round-tripping records to Lean: `const_weights` reduces each record in the task that owns it (48-byte `(addr, vspan, mult)` rows, one per checked constant), next to the peak reduction and before `gate.release` — admission keeps bounding peak RSS by the shards in flight rather than the whole partition. `prove_from_execution` is hoisted out of the two prove paths, taking the record BY VALUE: it is the witness phase's dominant residency and dies the instant the traces exist, before the LDE/commit/FRI phases that set the prover's peak. `prove_ixvm_within_budget` then measures `peak_prove_bytes` on the REAL record in the gap between execution and the witness phase: over budget, the record is dropped and the peak comes back instead of an OOM part-way into an FFT. Over budget is a RESULT, not an error — `proveBlocksWithinBudget` halves the block list and recurses (a shard is a plan, never part of a statement: halving yields claims exactly as valid as the parent's, each half's grown frontier discharged by its sibling), bottoming out at a single block, the atom the kernel checks together. The budget defaults to 85% of `MemAvailable`, the check batch's gate policy; `ix prove --max-ram G` takes the same units `ix shard` sized the partition with, and the run returns the partition it actually produced. Rejection costs one execution (0.65s) against a full prove (4.7s) on the 360-constant fixture; a 3.45 GiB shard against a 2 GiB budget recursed to four parts of 1.51-1.81 GiB in 11s, the parts partition the parent exactly (82+86+78+78 consts), and all proofs verify against unchanged claim digests. --- Ix/Aiur/Protocol.lean | 98 ++++++++++++++++--- Ix/Cli/CheckCmd.lean | 72 +++++--------- Ix/Cli/ProveCmd.lean | 138 +++++++++++++++++++------- crates/aiur/src/synthesis.rs | 146 +++++++++++++++++---------- crates/ffi/src/aiur/protocol.rs | 168 ++++++++++++++++++++++++++++---- crates/ffi/src/lean.rs | 4 + 6 files changed, 456 insertions(+), 170 deletions(-) diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 57f954a8c..2347747ed 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -173,17 +173,44 @@ def proveAddrWithEnv (system : @& AiurSystem) (proveAddrWithEnv' system funIdx envHandle addrBytes useBytecode).map fun r => (r.claimBytes, r.proof, .ofArrays r.ioData r.ioMap) +/-- Result of a per-shard prove: the claim's wire bytes, the proof, and + the projected prover RAM peak of the record that produced it + (`AiurSystem::peak_prove_bytes`). + + `proof` is `none` exactly when the peak exceeded the budget — a + RESULT rather than an error, since the caller's answer is to split + the shard and prove the halves, and `peakBytes` is what it decides + on. The claim bytes are filled either way (the claim is known before + proving starts). + + The final IO buffer is not returned — it is the shard's whole + ingested byte scope and no caller reads it. -/ +structure ShardProveResult where + claimBytes : ByteArray + proof : Option Proof + peakBytes : Nat + @[extern "rs_aiur_system_shard_prove_with_env"] private opaque shardProveWithEnv' : @& AiurSystem → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → - Except String ProveEnvResult - -/-- Per-shard prove against a Rust-owned `EnvHandle`. -/ + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → @& Nat → + Except String ShardProveResult + +/-- Per-shard prove against a Rust-owned `EnvHandle`: ONE execution, + whose record is proven from directly. + + `maxRamBytes` is a per-shard prover-RAM budget checked against that + record's projected peak before the witness phase begins; `0` means + detect (85% of `MemAvailable`, the policy the check batch's RAM gate + uses), and an unreadable `/proc/meminfo` disables the check rather + than guessing. Over budget, the record is dropped and `proof` is + `none` — learning that here costs one execution instead of an OOM + part-way through an FFT. The peak comes back either way, so a prove + run yields the same split/merge signal a check run does. -/ def shardProveWithEnv (system : @& AiurSystem) - (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (ownedBlob : ByteArray) : - Except String (ByteArray × Proof × IOBuffer) := - (shardProveWithEnv' system funIdx envHandle ownedBlob).map - fun r => (r.claimBytes, r.proof, .ofArrays r.ioData r.ioMap) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) + (ownedBlob : ByteArray) (maxRamBytes : Nat := 0) : + Except String ShardProveResult := + shardProveWithEnv' system funIdx envHandle ownedBlob maxRamBytes @[extern "rs_aiur_system_verify"] opaque verify : @& AiurSystem → @@ -193,21 +220,59 @@ end AiurSystem namespace Bytecode.Toplevel +/-- One shard's result from `shardCheckBatchWithEnv`. `weights` is the + shard's per-constant virtual-gas table, packed as 48-byte rows — + 32-byte address, then `vspan` and `mult` as little-endian `UInt64`s + (see `ShardResult.foldWeights`). Empty unless the batch ran with + `profile := true`; the record it is read from is reduced to these + rows and dropped inside the shard's own task, so a whole partition's + weights fit in RAM when its records could not. -/ +structure ShardResult where + error : String + peakBytes : Nat + weights : ByteArray + deriving Inhabited + +/-- Bytes per packed `weights` row: 32 address + 8 vspan + 8 mult. -/ +def shardWeightRow : Nat := 48 + +/-- Little-endian `UInt64` at `off`. -/ +private def readU64LE (ba : ByteArray) (off : Nat) : UInt64 := Id.run do + let mut v : UInt64 := 0 + for b in [0 : 8] do + v := v ||| ((ba.get! (off + b)).toUInt64 <<< (8 * b).toUInt64) + return v + +/-- Fold `f` over the packed `(addrBytes, vspan, mult)` rows of `weights`. + Trailing bytes that do not complete a row are ignored. -/ +@[inline] def ShardResult.foldWeights {α : Type} (r : ShardResult) (init : α) + (f : α → ByteArray → UInt64 → UInt64 → α) : α := Id.run do + let mut acc := init + for i in [0 : r.weights.size / shardWeightRow] do + let off := i * shardWeightRow + acc := f acc (r.weights.extract off (off + 32)) + (readU64LE r.weights (off + 32)) (readU64LE r.weights (off + 40)) + return acc + @[extern "rs_aiur_toplevel_shard_check_batch"] private opaque shardCheckBatchWithEnv' : @& Bytecode.Toplevel → @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → @& Nat → - @& CommitmentParameters → @& FriParameters → - Except String (Array (String × Nat)) + @& CommitmentParameters → @& FriParameters → Bool → @& Nat → + Except String (Array ShardResult) /-- Check EVERY shard of a partition in one call: rayon over the shard list with true work-stealing (no chunk barriers), each shard through the exact single-shard machinery over its own private record and witness io. `shardsBlob` encodes, per shard, a 4-byte LE owned-constant count followed by that many 32-byte addresses. - Returns one `(error, peakBytes)` pair per shard in shard order: - empty error = clean, and `peakBytes` is the analytic prover RAM - peak ([`AiurSystem::peak_prove_bytes`] Rust-side) of the shard's - executed record — the split/merge input (0 on failure). + Returns one `ShardResult` per shard in shard order: empty error = + clean, and `peakBytes` is the analytic prover RAM peak + ([`AiurSystem::peak_prove_bytes`] Rust-side) of the shard's executed + record — the split/merge input (0 on failure). `profile` turns on the + virtual-gas meter and fills each result's `weights` with the shard's + per-constant cost rows, read off the record inside the shard's own + task; `checkConstIdx` names the `check_const` function whose queries + those rows come from (ignored when not profiling). `jobs = 0` uses rayon's default pool width (all cores): peak RSS is bounded by the Rust-side RAM gate (a byte-weighted admission semaphore over estimated per-shard execution RSS vs available @@ -218,9 +283,10 @@ def shardCheckBatchWithEnv (toplevel : @& Bytecode.Toplevel) (shardsBlob : ByteArray) (useBytecode : Bool := false) (jobs : Nat := 0) (commitmentParameters : CommitmentParameters := defaultCommitmentParameters) (friParameters : FriParameters := defaultFriParameters) - : Except String (Array (String × Nat)) := + (profile : Bool := false) (checkConstIdx : Nat := 0) + : Except String (Array ShardResult) := shardCheckBatchWithEnv' toplevel funIdx envHandle shardsBlob useBytecode - jobs commitmentParameters friParameters + jobs commitmentParameters friParameters profile checkConstIdx end Bytecode.Toplevel diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index e67a97a5e..10d57a959 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -672,6 +672,7 @@ def shardsCover (ixonEnv : Ixon.Env) (shards : Array (Array Address)) : IO Bool soundness contract as `runShardCheckAll`. -/ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) (compiled : Aiur.CompiledToplevel) (useBytecode : Bool) + (profileOut : Option String) (json? : Option (String × String) := none) : IO UInt32 := do -- The row's peak-rss needs the process-tree RSS sampler running -- (`peakTreeRssBytes` reports 0 otherwise); started before the env @@ -713,21 +714,37 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) (← IO.getStdout).flush let totalConsts := ownedPerShard.foldl (· + ·.size) 0 let start ← IO.monoMsNow + -- `check_const`'s queries are what the weight rows are read from; a + -- toplevel without it can still check, just not profile. + let checkConstIdx := (compiled.getFuncIdx `check_const).getD 0 + if profileOut.isSome && (compiled.getFuncIdx `check_const).isNone then + IO.eprintln "--profile: no `check_const` in compiled toplevel" match compiled.bytecode.shardCheckBatchWithEnv funIdx envHandle blob useBytecode jobs Aiur.defaultCommitmentParameters - Aiur.defaultFriParameters with + Aiur.defaultFriParameters profileOut.isSome checkConstIdx with | .error e => IO.eprintln s!"shard batch: {e}"; return 1 | .ok results => let elapsedMs := (← IO.monoMsNow) - start let mut failures : Nat := 0 for k in [:results.size] do - let (err, peak) := results[k]! - if err.isEmpty then - let gib := Float.ofNat peak / 1073741824.0 + let r := results[k]! + if r.error.isEmpty then + let gib := Float.ofNat r.peakBytes / 1073741824.0 IO.println s!"[shard {k}] ok, projected prover peak {gib} GiB" else - IO.eprintln s!"[shard {k}] FAILED: {err}" + IO.eprintln s!"[shard {k}] FAILED: {r.error}" failures := failures + 1 + -- Weight rows are appended once for the whole batch: Rust already + -- reduced each shard's record under its own task, so nothing here + -- holds a record alive. + if let some out := profileOut then + let h ← IO.FS.Handle.mk out .append + for r in results do + h.putStr <| r.foldWeights "" fun acc addrBytes vspan mult => + let addr : Address := ⟨addrBytes⟩ + let name := (ixonEnv.addrToName.get? addr).map (s!" {·}") |>.getD "" + acc ++ s!"{addr} {vspan} {mult}{name}\n" + h.flush -- One env-keyed results row for `ix bench run --backend aiur-sharded-env`: -- the measured window is the batch FFI call (env load and blob -- setup are excluded, matching what the benchmark tracks — the @@ -752,42 +769,6 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) -- exit (the row is already written), same contract as `check-rs`. return if json?.isSome then Ix.Benchmark.Results.exitRejected else 1 -/-- Per-shard IxVM-native check over EVERY shard, one Lean task per - shard. Slower than `runShardBatchNative` (chunk barriers idle - workers on each wave's slowest shard), but it keeps each shard's - `QueryRecord` Lean-side, which is what `--profile` needs: the - batch FFI returns only a per-shard verdict and prover peak, not - the records the virtual-gas dump reads. Builds the `EnvHandle` - ONCE and shares it across every shard's FFI call (no per-shard - re-mmap). Coverage-gates the manifest before running any shard — - exit 0 has to mean "every env const was checked by some shard", - same soundness contract as `runShardCheckAll`. -/ -def runShardManifestAllNative (manifestPath ixePath : String) (jobs? : Option Nat) - (compiled : Aiur.CompiledToplevel) (printStats : Bool) - (statsOut : Option String) (profileOut : Option String) - (useBytecode : Bool) : IO UInt32 := do - match (← loadEnvAndShards manifestPath ixePath) with - | .error e => IO.eprintln e; return 1 - | .ok (ixonEnv, shards) => - if !(← shardsCover ixonEnv shards) then return 1 - let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with - | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 - | .ok h => pure h - let shapes := Aiur.circuitShapes compiled.bytecode - Aiur.defaultCommitmentParameters Aiur.defaultFriParameters - let maxJobs := max 1 (jobs?.getD shards.size) - let mut rc : UInt32 := 0 - for chunk in (shards.mapIdx (fun k b => (b, k))).toList.toChunks maxJobs do - let tasks ← chunk.mapM fun (blocks, k) => - IO.asTask (prio := .dedicated) - (runShardOwnedNative envHandle compiled printStats statsOut profileOut - useBytecode shapes ixonEnv blocks k) - for t in tasks do - match t.get with - | .ok r => if r != 0 then rc := 1 - | .error e => IO.eprintln s!"shard check task failed: {e}"; rc := 1 - pure rc - /-- Run the shard operation over EVERY shard — the whole-partition behavior of `--ixes` with no `--shard` (used by `prove`). Loads the env once. Returns 1 if any shard fails, else 0. -/ @@ -908,17 +889,10 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c - -- `--profile` needs each shard's `QueryRecord`, which the rayon - -- batch does not hand back; that run takes the per-shard Lean - -- task path instead. - if profileOut.isSome then - return (← runShardManifestAllNative manifest ixe - ((p.flag? "jobs").map (·.as! Nat)) compiled printStats statsOut - profileOut useBytecode) let json? := (p.flag? "json").map fun f => (f.as! String, ((p.flag? "json-name").map (·.as! String)).getD "env") return (← runShardBatchNative manifest ixe - ((p.flag? "jobs").map (·.as! Nat)) compiled useBytecode json?) + ((p.flag? "jobs").map (·.as! Nat)) compiled useBytecode profileOut json?) | _, _, _ => -- `--jobs N` (N ≠ 1) with an `--ixe` env and no `--claim` takes the -- parallel batch path: one FFI call, rayon over the target list, diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index a35609d9a..4efa86a7c 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -86,7 +86,13 @@ def proveOne (aiurSystem : Aiur.AiurSystem) | .error e => IO.eprintln s!"{label}: shardProveWithEnv error: {e}" return 1 - | .ok (_claimBytes, proof, _outIO) => pure proof + | .ok r => match r.proof with + | some proof => pure proof + | none => + IO.eprintln s!"{label}: projected prover peak {r.peakBytes} bytes \ + exceeds the budget; this target is not a manifest shard, so it \ + cannot be split — raise --max-ram" + return 1 | .leanW witness, _ => let (_aiurClaim, proof, _outIO) := aiurSystem.proveIxVM funIdx witness.input witness.inputIOBuffer @@ -99,47 +105,98 @@ def proveOne (aiurSystem : Aiur.AiurSystem) IO.println (toString proofAddr) return 0 -/-- Per-shard prove via the end-to-end Rust path - (`shardProveIxVM`): witness build, `execute_ixvm`, and STARK - prove run in one FFI trip with the parallel Rust witness - builder. -/ -def runShardProveNative (manifestPath : String) (envHandle : Aiur.EnvHandle) - (ixonEnv : Ixon.Env) (shards : Array (Array Address)) (shardK : Nat) - (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) - (_printStats : Bool) : IO UInt32 := do - match shards[shardK]? with - | none => IO.eprintln s!"shard {shardK} out of range (0..{shards.size})"; return 1 - | some blocks => do - let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks ixonEnv blocks - let mut blob := ByteArray.empty - for a in owned do - blob := blob ++ a.hash - let label := s!"shard {shardK}" - IO.println s!"Proving {label}" - (← IO.getStdout).flush - let funIdx := compiled.getFuncIdx `verify_claim |>.get! - match aiurSystem.shardProveWithEnv funIdx envHandle blob with - | .error e => - IO.eprintln s!"{label}: shardProveWithEnv error: {e}" - return 1 - | .ok (claimBytes, proof, _outIO) => +/-- Prove the constants owned by `blocks` as ONE shard, splitting and + recursing whenever the executed record's projected prover peak + exceeds the budget. + + A shard is only a plan, never part of a statement: its claim is + `checkEnv(ownedRoot, asmRoot)`, a pure function of `(env, owned)` + with the frontier recomputed from the owned set. So halving `blocks` + yields two claims exactly as valid as the parent's — each half's + grown frontier is discharged by its sibling — and the split costs + only the parent's execution, the cheap half of the run. Splitting on + BLOCKS rather than constants is what keeps mutual-recursion groups + intact, since every constant maps to exactly one block. + + Returns the block sets actually proven, in proof order: the parent's + own when it fit, otherwise its descendants'. That is the partition + the run really produced, which is what an updated manifest has to + describe once the whole pipeline is done. -/ +partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) + (ixonEnv : Ixon.Env) (aiurSystem : Aiur.AiurSystem) + (funIdx : Aiur.Bytecode.FunIdx) (maxRamBytes : Nat) (label : String) + (blocks : Array Address) : IO (Except String (Array (Array Address))) := do + let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks ixonEnv blocks + let mut blob := ByteArray.empty + for a in owned do + blob := blob ++ a.hash + IO.println s!"Proving {label} ({blocks.size} blocks, {owned.size} consts)" + (← IO.getStdout).flush + match aiurSystem.shardProveWithEnv funIdx envHandle blob maxRamBytes with + | .error e => return .error s!"{label}: shardProveWithEnv error: {e}" + | .ok { claimBytes, proof, peakBytes } => + let gib := Float.ofNat peakBytes / 1073741824.0 + match proof with + | none => + -- A single block is the atom the kernel checks together; there is + -- no smaller shard to fall back to. + if blocks.size <= 1 then + return .error s!"{label}: projected prover peak {gib} GiB exceeds \ + the budget and the shard is a single block — raise --max-ram" + let mid := blocks.size / 2 + IO.println s!"[{label}] peak {gib} GiB over budget — splitting \ + {blocks.size} blocks into {mid} + {blocks.size - mid}" + match ← proveBlocksWithinBudget envHandle ixonEnv aiurSystem funIdx + maxRamBytes s!"{label}.0" (blocks.extract 0 mid) with + | .error e => return .error e + | .ok lo => + match ← proveBlocksWithinBudget envHandle ixonEnv aiurSystem funIdx + maxRamBytes s!"{label}.1" (blocks.extract mid blocks.size) with + | .error e => return .error e + | .ok hi => return .ok (lo ++ hi) + | some proof => + IO.println s!"[{label}] prover peak {gib} GiB" -- Rust returns the canonical CheckEnv claim's wire bytes; deserialize -- back to `Ix.Claim` to persist alongside the proof. Avoids -- recomputing the closure walk + canonical AssumptionTree Lean-side. match Ixon.runGet Ix.Claim.get claimBytes with - | .error e => - IO.eprintln s!"{label}: Claim wire-decode failed: {e}" - return 1 + | .error e => return .error s!"{label}: Claim wire-decode failed: {e}" | .ok claim => do let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) IO.println (toString proofAddr) - let _ := manifestPath -- kept for parity with previous signature - return 0 + return .ok #[blocks] + +/-- Prove shard `shardK` of the partition, splitting it as needed. + Returns the block sets actually proven for that shard. -/ +def runShardProveNative (envHandle : Aiur.EnvHandle) (ixonEnv : Ixon.Env) + (shards : Array (Array Address)) (shardK : Nat) + (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) + (maxRamBytes : Nat) : IO (Except String (Array (Array Address))) := do + match shards[shardK]? with + | none => return .error s!"shard {shardK} out of range (0..{shards.size})" + | some blocks => + let funIdx := compiled.getFuncIdx `verify_claim |>.get! + proveBlocksWithinBudget envHandle ixonEnv aiurSystem funIdx maxRamBytes + s!"shard {shardK}" blocks + +/-- Report the partition a prove run actually produced against the one + its manifest planned. They differ exactly when a shard was split. -/ +def reportPartition (proven : Array (Array Address)) (planned : Nat) : IO Unit := do + if proven.size == planned then + IO.println s!"[prove] {proven.size} shard(s) proven, partition unchanged" + else + IO.println s!"[prove] {proven.size} shard(s) proven from {planned} planned \ + ({proven.size - planned} from splits) — re-shard with this partition to \ + skip the splits next run" def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let keepGoing := p.hasFlag "keep-going" + -- Same units as `ix shard --max-ram`: the per-shard prover budget the + -- partition was sized against, re-checked here against each shard's + -- measured peak. 0 = unchecked. + let maxRamBytes := ((p.flag? "max-ram").map (·.as! Nat)).getD 0 * 1073741824 let ixePath : Option String := (p.flag? "ixe").map (·.as! String) let claimHex : Option String := (p.flag? "claim").map (·.as! String) let names := (p.variableArgsAs! String).toList @@ -161,7 +218,12 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let envHandle ← match Aiur.EnvHandle.fromIxe ixe with | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 | .ok h => pure h - runShardProveNative manifest envHandle ixonEnv shards k aiurSystem compiled false + match ← runShardProveNative envHandle ixonEnv shards k aiurSystem + compiled maxRamBytes with + | .error e => IO.eprintln e; return 1 + | .ok parts => + reportPartition parts shards.size + return 0 | some ixe, some manifest, none => -- IxVM-native all-shards prove. Same envHandle reused across -- every shard. @@ -171,11 +233,18 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let envHandle ← match Aiur.EnvHandle.fromIxe ixe with | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 | .ok h => pure h + -- Accumulate the partition the run actually produced. Splits stay + -- in this process, so the manifest describing them is written + -- once at the end rather than rewritten per split. + let mut proven : Array (Array Address) := #[] let mut rc : UInt32 := 0 for k in [0 : shards.size] do - if (← runShardProveNative manifest envHandle ixonEnv shards k - aiurSystem compiled false) != 0 then - rc := 1 + match ← runShardProveNative envHandle ixonEnv shards k aiurSystem + compiled maxRamBytes with + | .error e => IO.eprintln e; rc := 1 + | .ok parts => proven := proven ++ parts + if rc == 0 then reportPartition proven shards.size + let _ := manifest pure rc | _, _, _ => Ix.Cli.CheckCmd.forEachClaim ixePath claimHex names keepGoing "prove" false runOne @@ -193,6 +262,7 @@ def proveCmd : Cli.Cmd := `[Cli| "claim" : String; "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, proves the persisted claim against the `--ixe` env (single proof, skips per-const iteration)." "ixes" : String; "Path to a `.ixes` shard manifest (with --ixe). With --shard K: prove shard K. Without --shard: prove every shard in the partition." "shard" : Nat; "0-based shard index K (with --ixes and --ixe): prove that one shard's CheckEnv claim." + "max-ram" : Nat; "Per-shard prover-RAM budget, GiB — normally the same value the partition was sized with (`ix shard --max-ram`). Each shard is executed, its projected prover peak measured on the resulting record, and the proof attempted only if it fits; an over-budget shard is reported (split it and re-run) instead of being taken into the FFT phases that would exhaust the box. Omit to prove unconditionally." ARGS: ...names : String; "Fully-qualified Lean.Name(s) to prove. With none, iterate every named constant in the env (sorted)." diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 303dae6d7..14ff4d268 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -302,26 +302,32 @@ impl AiurSystem { } } - #[tracing::instrument(level = "info", skip_all, name = "aiur/prove")] - pub fn prove( + /// Prove an execution that has ALREADY happened: everything from the + /// witness phase on, over a record the caller hands across. + /// + /// Taking `query_record` by value is the point. The record is the + /// witness phase's dominant residency, and it is dropped here the + /// instant the traces exist — before the LDE/commit/FRI phases that + /// actually set the prover's peak (see [`Self::peak_prove_bytes`]). + /// A caller that keeps its own copy alive past this call pays that + /// peak *on top of* the record, which at shard scale is the + /// difference between fitting in RAM and not. + /// + /// `input`, `io_buffer` and `output` must be the ones the execution + /// ran on: they reconstruct the claim the proof commits to, and the + /// witness reads the buffer the execution left behind. + /// + /// Deliberately not `#[tracing::instrument]`ed — the `aiur/witness` + /// span below stays directly under the caller's `aiur/prove*` span, + /// so the stage-scoped measurements keep their existing shape. + pub fn prove_from_execution( &self, fun_idx: FunIdx, input: &[G], - io_buffer: &mut IOBuffer, + io_buffer: &IOBuffer, + query_record: QueryRecord, + output: &[G], ) -> (Vec, AiurProof) { - tracing_texray::examine_current(); - - // Execute the Aiur bytecode. - let _g = tracing::info_span!("aiur/execute").entered(); - // Execute the Aiur bytecode. The prover assumes inputs are valid; any - // execution error here is a programmer bug, so we unwrap. - let (query_record, output) = self - .toplevel - .execute(fun_idx, input.to_vec(), io_buffer, false) - .expect("Aiur execution failed during prove"); - drop(_g); - - // Build the `SystemWitness` let _g = tracing::info_span!("aiur/witness").entered(); let circuit_types = self.circuit_types(); let witness_data = circuit_types @@ -363,6 +369,28 @@ impl AiurSystem { (claim, proof) } + #[tracing::instrument(level = "info", skip_all, name = "aiur/prove")] + pub fn prove( + &self, + fun_idx: FunIdx, + input: &[G], + io_buffer: &mut IOBuffer, + ) -> (Vec, AiurProof) { + tracing_texray::examine_current(); + + // Execute the Aiur bytecode. + let _g = tracing::info_span!("aiur/execute").entered(); + // Execute the Aiur bytecode. The prover assumes inputs are valid; any + // execution error here is a programmer bug, so we unwrap. + let (query_record, output) = self + .toplevel + .execute(fun_idx, input.to_vec(), io_buffer, false) + .expect("Aiur execution failed during prove"); + drop(_g); + + self.prove_from_execution(fun_idx, input, io_buffer, query_record, &output) + } + /// IxVM-native prove: identical to `prove` except the execute step /// is provided by the caller as `executor` (a closure that runs /// the codegen'd Rust kernel `ix::aiur_ixvm_runner::execute_ixvm` @@ -381,6 +409,48 @@ impl AiurSystem { io_buffer: &mut IOBuffer, executor: F, ) -> (Vec, AiurProof) + where + F: FnOnce( + &Toplevel, + FunIdx, + Vec, + &mut IOBuffer, + ) -> Result<(QueryRecord, Vec), ExecError>, + { + self + .prove_ixvm_within_budget(fun_idx, input, io_buffer, executor, None) + .map_or_else( + |_| unreachable!("an unbudgeted prove never rejects"), + |(claim, proof, _peak)| (claim, proof), + ) + } + + /// `prove_ixvm`, but the record's projected prover peak has to fit + /// `max_bytes` before any proving starts. `None` skips the check. + /// + /// The peak is measured on the REAL record ([`Self::peak_prove_bytes`]), + /// not estimated from serialized bytes, so an over-budget shard is + /// caught in the gap between execution and the witness phase — before + /// the LDE/commit/FRI phases that would actually exhaust the box. The + /// record is dropped rather than proven and the peak comes back as + /// `Err(peak)`, which is the number a caller splits the shard against. + /// + /// On success the peak is returned too: proving a shard measures it for + /// free, so a prove run yields the same split/merge signal a check run + /// does without a second execution. + #[tracing::instrument( + level = "info", + skip_all, + name = "aiur/prove_ixvm_within_budget" + )] + pub fn prove_ixvm_within_budget( + &self, + fun_idx: FunIdx, + input: &[G], + io_buffer: &mut IOBuffer, + executor: F, + max_bytes: Option, + ) -> Result<(Vec, AiurProof, usize), usize> where F: FnOnce( &Toplevel, @@ -396,43 +466,13 @@ impl AiurSystem { .expect("IxVM-native Aiur execution failed during prove_ixvm"); drop(_g); - let _g = tracing::info_span!("aiur/witness").entered(); - let circuit_types = self.circuit_types(); - let witness_data = circuit_types - .into_par_iter() - .enumerate() - .map(|(circuit_idx, circuit_type)| { - let slot_arg_widths = self.slot_arg_widths(circuit_idx); - match circuit_type { - CircuitType::Function { idx } => self.toplevel.witness_data( - idx, - &query_record, - io_buffer, - &slot_arg_widths, - ), - CircuitType::Memory { width } => { - Memory::witness_data(width, &query_record, &slot_arg_widths) - }, - CircuitType::Bytes1 => { - Bytes1.witness_data(&query_record, &slot_arg_widths) - }, - CircuitType::Bytes2 => { - Bytes2.witness_data(&query_record, &slot_arg_widths) - }, - } - }) - .collect::>(); - drop(query_record); - let (traces, lookups) = witness_data.into_iter().unzip(); - let witness = SystemWitness { traces, lookups }; - drop(_g); - - let mut claim = vec![function_channel(), G::from_usize(fun_idx)]; - claim.extend(input); - claim.extend(output); - - let proof = self.system.prove(&self.key, &claim, witness); - (claim, proof) + let peak = self.peak_prove_bytes(&query_record).peak; + if max_bytes.is_some_and(|max| peak > max) { + return Err(peak); + } + let (claim, proof) = + self.prove_from_execution(fun_idx, input, io_buffer, query_record, &output); + Ok((claim, proof, peak)) } #[inline] diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index aa6ad5c3c..20f5491c5 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -7,7 +7,8 @@ use std::sync::LazyLock; use lean_ffi::object::{ ExternalClass, LeanArray, LeanBorrowed, LeanByteArray, LeanExcept, - LeanExternal, LeanNat, LeanOwned, LeanProd, LeanRef, LeanString, + LeanExternal, LeanNat, LeanOption, LeanOwned, LeanProd, LeanRef, + LeanString, }; use crate::{ @@ -15,7 +16,8 @@ use crate::{ lean::{ LeanAiurCircuitShape, LeanAiurCommitmentParameters, LeanAiurExecuteResult, LeanAiurFriParameters, LeanAiurIOKeyInfo, LeanAiurProveEnvResult, - LeanAiurProveResult, LeanAiurQueryCount, LeanAiurToplevel, + LeanAiurProveResult, LeanAiurQueryCount, LeanAiurShardProveResult, + LeanAiurShardResult, LeanAiurToplevel, }, }; use aiur::{ @@ -738,6 +740,80 @@ fn available_ram_bytes() -> Option { Some(kib * 1024) } +/// Decode a `memory[32]` entry as a 32-byte address. Every limb has to be a +/// byte: an entry whose limbs are not byte-valued is some other `&[T; 32]` +/// the pointer aliased, not an `Addr`, so the caller skips that row rather +/// than recording a truncated address. +fn limbs_to_addr(limbs: &[G]) -> Option<[u8; 32]> { + let mut addr = [0u8; 32]; + if limbs.len() != addr.len() { + return None; + } + for (byte, limb) in addr.iter_mut().zip(limbs) { + *byte = u8::try_from(limb.as_canonical_u64()).ok()?; + } + Some(addr) +} + +/// Serialized width of one [`const_weights`] row: 32-byte address, then +/// `vspan` and `mult` as little-endian `u64`s. +const CONST_WEIGHT_ROW: usize = 48; + +/// Reduce an executed record to per-constant weights, so the record can be +/// dropped inside the task that produced it: at env scale the records of a +/// whole partition do not fit in RAM at once, but one 48-byte row per +/// checked constant does. +/// +/// Rows come from the `check_const` query map (`check_const_idx`), whose +/// entries name the constants this shard actually checked. The address is +/// the LAST input slot — `ci` is passed flattened by value — dereferenced +/// through `memory[32]`. `vspan` is the constant's standalone check cost +/// (memo hits replay the callee's recorded span), so the weights are +/// order-independent and stay valid for planning a DIFFERENT partition +/// than the one that measured them. Unconstrained hint rows +/// (multiplicity 0) are skipped: they are not checks. +/// +/// Empty unless the execution ran with `profile = true`; without it every +/// span reads 0 and the rows carry no signal. +fn const_weights( + record: &QueryRecord, + toplevel: &aiur::bytecode::Toplevel, + check_const_idx: usize, +) -> Vec { + let (Some(map), Some(function)) = ( + record.function_queries.get(check_const_idx), + toplevel.functions.get(check_const_idx), + ) else { + return Vec::new(); + }; + let Some(addr_pos) = function.layout.input_size.checked_sub(1) else { + return Vec::new(); + }; + let memory = record.memory_queries.get(&32); + let mut rows = Vec::with_capacity(map.len() * CONST_WEIGHT_ROW); + for i in 0..map.len() { + let mult = map.mult_at(i).as_canonical_u64(); + if mult == 0 { + continue; + } + let Some(ptr) = map.get_index(i).and_then(|(key, _)| key.get(addr_pos)) + else { + continue; + }; + let ptr = usize::try_from(ptr.as_canonical_u64()).unwrap_or(usize::MAX); + let Some(addr) = memory + .and_then(|m| m.get_index(ptr).map(|(k, _)| k)) + .and_then(limbs_to_addr) + else { + continue; + }; + rows.extend_from_slice(&addr); + rows.extend_from_slice(&map.vspan_at(i).to_le_bytes()); + rows.extend_from_slice(&mult.to_le_bytes()); + } + rows +} + /// `Bytecode.Toplevel.shardCheckBatchWithEnv`: check EVERY shard of a /// partition in one call — rayon over the shard list with true /// work-stealing (no chunk barriers), each shard through the exact @@ -748,12 +824,14 @@ fn available_ram_bytes() -> Option { /// /// `shards_blob` encodes the partition as, per shard, a 4-byte LE /// owned-constant count followed by that many 32-byte addresses. -/// Returns one `(error, peak_bytes)` pair PER SHARD in shard order: +/// Returns one `(error, peak_bytes, weights)` triple PER SHARD in shard order: /// an empty error string means the shard checked clean, and /// `peak_bytes` is the analytic prover peak /// ([`aiur::synthesis::AiurSystem::peak_prove_bytes`]) of its executed /// record — the number split/merge decisions compare against a prover -/// budget (0 when the shard failed). `jobs = 0` uses rayon's default +/// budget (0 when the shard failed). `weights` is the shard's +/// [`const_weights`] blob — empty unless `profile`, which also enables +/// the per-entry virtual-gas meter the blob reads. `jobs = 0` uses rayon's default /// pool width (all cores) — safe at full width because admission is /// bounded by [`RamGate`], not by thread count; pass `jobs` only to /// narrow CPU use. @@ -773,11 +851,14 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( jobs: LeanNat>, commitment_parameters: LeanAiurCommitmentParameters>, fri_parameters: LeanAiurFriParameters>, + profile: bool, + check_const_idx: LeanNat>, ) -> LeanExcept { use rayon::prelude::*; let toplevel = decode_toplevel(&toplevel_obj); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); let jobs = lean_unbox_nat_as_usize(jobs.inner()); + let check_const_idx = lean_unbox_nat_as_usize(check_const_idx.inner()); let mut shards: Vec> = Vec::new(); { let bytes = shards_blob.as_bytes(); @@ -843,7 +924,7 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( max as f64 / gib, ); } - let check_batch = || -> Vec<(String, usize)> { + let check_batch = || -> Vec<(String, usize, Vec)> { shards .par_iter() .zip(estimates.par_iter()) @@ -853,19 +934,28 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness( env, owned, ) { - Err(e) => (format!("witness build: {e}"), 0), + Err(e) => (format!("witness build: {e}"), 0, Vec::new()), Ok((_claim, input, mut io_buffer)) => match dispatch_execute( &toplevel, fun_idx, input, &mut io_buffer, use_bytecode, - // No vspan meter: only the prover peak is read back per shard. - false, + profile, ) { - Err(e) => (e, 0), + Err(e) => (e, 0, Vec::new()), + // Both reductions happen here, while the record is still + // owned by this task: it is dropped before `gate.release`, + // so admission keeps bounding peak RSS by the shards in + // flight rather than by the whole partition. Ok((record, _output)) => { - (String::new(), system.peak_prove_bytes(&record).peak) + let peak = system.peak_prove_bytes(&record).peak; + let weights = if profile { + const_weights(&record, &toplevel, check_const_idx) + } else { + Vec::new() + }; + (String::new(), peak, weights) }, }, }; @@ -886,9 +976,12 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( pool.install(check_batch) }; let arr = LeanArray::alloc(results.len()); - for (i, (err, peak)) in results.iter().enumerate() { - arr - .set(i, LeanProd::new(LeanString::new(err), LeanOwned::box_usize(*peak))); + for (i, (err, peak, weights)) in results.iter().enumerate() { + let row = LeanAiurShardResult::alloc(0); + row.set_obj(0, LeanString::new(err)); + row.set_obj(1, LeanOwned::box_usize(*peak)); + row.set_obj(2, LeanByteArray::from_bytes(weights)); + arr.set(i, row); } LeanExcept::ok(arr) } @@ -1010,9 +1103,25 @@ extern "C" fn rs_aiur_system_prove_addr_with_env( LeanExcept::ok(build_prove_env_result(&claim, proof, &io_buffer)) } -/// `AiurSystem.shardProveWithEnv`: per-shard prove against a -/// Rust-owned `EnvHandle`. Same `ProveEnvResult` return shape as -/// `proveAddrWithEnv`. +/// `AiurSystem.shardProveWithEnv`: per-shard prove against a Rust-owned +/// `EnvHandle`, executing ONCE and proving from that record. +/// +/// `max_ram_bytes` is a per-shard prover-RAM budget checked against the +/// executed record's projected peak, in the gap between execution and +/// the witness phase. `0` means "detect": 85% of `MemAvailable`, the +/// same policy the check batch's RAM gate uses. An unreadable +/// `/proc/meminfo` disables the check rather than guessing at it. +/// +/// Over budget, the record is dropped and `proof` comes back as `none` +/// with the measured `peakBytes`. That is a RESULT, not an error: the +/// caller's answer is to split the shard and prove the halves, and it +/// needs the peak to decide. Learning this here costs one execution +/// instead of an OOM part-way through an FFT. +/// +/// Returns `(claimBytes, proof?, peakBytes)`. The final IO buffer is +/// deliberately NOT returned: it is the shard's whole ingested byte +/// scope, both Lean callers discarded it, and marshalling it back is +/// pure cost on the largest buffers in the system. #[unsafe(no_mangle)] extern "C" fn rs_aiur_system_shard_prove_with_env( aiur_system_obj: LeanExternal>, @@ -1022,8 +1131,10 @@ extern "C" fn rs_aiur_system_shard_prove_with_env( LeanBorrowed<'_>, >, owned_blob: LeanByteArray>, + max_ram_bytes: LeanNat>, ) -> LeanExcept { let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner()); let owned = match decode_owned_blob(&owned_blob) { Ok(v) => v, Err(e) => return LeanExcept::error_string(&e), @@ -1040,7 +1151,14 @@ extern "C" fn rs_aiur_system_shard_prove_with_env( }, }; - let (_aiur_claim_arr, proof) = aiur_system_obj.get().prove_ixvm( + // 0 = detect. Matching the check batch's gate keeps one RAM policy in + // the system rather than two that can disagree. + let budget = if max_ram_bytes > 0 { + Some(max_ram_bytes) + } else { + available_ram_bytes().map(|b| b / 100 * 85) + }; + let proved = aiur_system_obj.get().prove_ixvm_within_budget( fun_idx, &input, &mut io_buffer, @@ -1050,9 +1168,23 @@ extern "C" fn rs_aiur_system_shard_prove_with_env( toplevel, fun_idx, input, io_buffer, false, ) }, + budget, ); + let (proof, peak) = match proved { + Ok((_aiur_claim_arr, proof, peak)) => (LeanOption::some( + LeanExternal::alloc(&AIUR_PROOF_CLASS, proof), + ), peak), + Err(peak) => (LeanOption::none(), peak), + }; + drop(io_buffer); - LeanExcept::ok(build_prove_env_result(&claim, proof, &io_buffer)) + let mut claim_bytes: Vec = Vec::new(); + claim.put(&mut claim_bytes); + let result = LeanAiurShardProveResult::alloc(0); + result.set_obj(0, LeanByteArray::from_bytes(&claim_bytes)); + result.set_obj(1, proof); + result.set_obj(2, LeanOwned::box_usize(peak)); + LeanExcept::ok(result) } /// `AiurSystem.proveIxVM`: IxVM-native prove path. Same return shape diff --git a/crates/ffi/src/lean.rs b/crates/ffi/src/lean.rs index 793965627..fbcdc5519 100644 --- a/crates/ffi/src/lean.rs +++ b/crates/ffi/src/lean.rs @@ -294,6 +294,10 @@ lean_ffi::lean_inductive! { LeanAiurProveResult [ { num_obj: 4 } ]; // claimBytes, proof, ioData, ioMap LeanAiurProveEnvResult [ { num_obj: 4 } ]; + // error, peakBytes, weights + LeanAiurShardResult [ { num_obj: 3 } ]; + // claimBytes, proof, peakBytes + LeanAiurShardProveResult [ { num_obj: 3 } ]; // --- Block / comparison types --- From f529e0925c5aab069153d456cea605d8311107f2 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Thu, 27 Aug 2026 22:51:00 +0000 Subject: [PATCH 07/44] aiur: model-driven splitting, exec-only audits, corrected-manifest emit MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit An over-budget shard is now cut into the part count the peak model projects will fit, in one step, instead of bisecting blindly: suggested_split_parts re-evaluates peak_prove_bytes_by with each circuit's raw counts scaled 1/n (n = 2, 4, ...) until it fits — the model's power-of-two padding, fixed gadget floor and max-of-phases handled by construction. The estimate is optimistic (parts re-execute dependencies shared across the cut), so every part is still gated on its own executed record; optimism is the right bias, since an under-split costs one cheap re-execution while an over-split pays the per-proof floor forever. Measured on the 241-shard FLT/ram400 partition: 6 shards over budget (437-648 GiB vs 400), every one resolved by a single suggested halving — max recursion depth 1, final partition maxing at 99.7% of budget. Equal-cumulative-vspan cut placement was implemented, benchmarked against equal block counts on a 360-const fixture, init and lean, lost on parts/depth/executions on every env (vspan tracks time, not rows), and is not kept. ix prove --exec-only runs the same split loop on executions alone (execute_peak_ixvm: execute, measure, suggest — no STARK), and ix check --ixes --max-ram G is its batch twin: one wave loop where wave 0 is the plain batch check, over-budget shards are cut and their parts re-batched under the rayon scheduler + RAM gate, and the wave count is the split depth. --profile records vspans from wave 0 only — they are partition-invariant, so the first full pass already carries every constant's row. Both drivers now finish by enumerating exactly which shards failed, and can emit the partition the run ACTUALLY produced as a .ixes via rs_shard_manifest_from_partition (--out-ixes): coverage validated, own/foreign/cross-ingress and assumption roots rebuilt from the static profile, and each shard's measured prover peak recorded in a trailing manifest section (older readers ignore it; 0 = unmeasured planner output) — the scheduling signal, since STARK wall is ~linear in peak (92-112s at 229-278 GiB vs 217s at 472 GiB). Emitted manifests are fixed points: re-running on one produces zero splits and re-emits it byte-identically. Also: ix prove --texray streams the per-phase timing/RSS lines (execute / witness / stark stages) — Mathlib shards measure ~30s execute vs ~100s STARK on this engine, retiring the arena-port urgency; the prove-path --max-ram docs now match the FFI (0 = detect 85% of MemAvailable, not unchecked); the checkAddrsWithEnv docstring now matches the batch-index return. --- Ix/Aiur/Protocol.lean | 52 +++++-- Ix/Aiur/Semantics/BytecodeFfi.lean | 3 +- Ix/Cli/CheckCmd.lean | 241 ++++++++++++++++++++--------- Ix/Cli/ProveCmd.lean | 136 +++++++++++----- Ix/KernelCheck.lean | 17 ++ crates/aiur/src/synthesis.rs | 102 +++++++++++- crates/ffi/src/aiur/protocol.rs | 92 +++++++---- crates/ffi/src/kernel.rs | 104 ++++++++++++- crates/ffi/src/lean.rs | 8 +- crates/kernel/src/shard.rs | 55 +++++++ 10 files changed, 641 insertions(+), 169 deletions(-) diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 2347747ed..19ae0791e 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -173,15 +173,21 @@ def proveAddrWithEnv (system : @& AiurSystem) (proveAddrWithEnv' system funIdx envHandle addrBytes useBytecode).map fun r => (r.claimBytes, r.proof, .ofArrays r.ioData r.ioMap) -/-- Result of a per-shard prove: the claim's wire bytes, the proof, and - the projected prover RAM peak of the record that produced it - (`AiurSystem::peak_prove_bytes`). +/-- Result of a per-shard prove: the claim's wire bytes, the proof, the + projected prover RAM peak of the record that produced it + (`AiurSystem::peak_prove_bytes`), and the part count the peak model + projects will fit the budget + (`AiurSystem::suggested_split_parts`). `proof` is `none` exactly when the peak exceeded the budget — a - RESULT rather than an error, since the caller's answer is to split - the shard and prove the halves, and `peakBytes` is what it decides - on. The claim bytes are filled either way (the claim is known before - proving starts). + RESULT rather than an error, since the caller's answer is to cut + the shard into `suggestedParts` parts and prove those. The count is + computed Rust-side because only there does the executed record + still exist to read per-circuit heights from; it is optimistic + (parts re-execute dependencies shared across the cut), so each part + must still be gated on its own record. `suggestedParts` is 1 + whenever the prove ran. The claim bytes are filled either way (the + claim is known before proving starts). The final IO buffer is not returned — it is the shard's whole ingested byte scope and no caller reads it. -/ @@ -189,10 +195,11 @@ structure ShardProveResult where claimBytes : ByteArray proof : Option Proof peakBytes : Nat + suggestedParts : Nat @[extern "rs_aiur_system_shard_prove_with_env"] private opaque shardProveWithEnv' : @& AiurSystem → - @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → @& Nat → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → @& Nat → Bool → Except String ShardProveResult /-- Per-shard prove against a Rust-owned `EnvHandle`: ONE execution, @@ -205,12 +212,17 @@ private opaque shardProveWithEnv' : @& AiurSystem → than guessing. Over budget, the record is dropped and `proof` is `none` — learning that here costs one execution instead of an OOM part-way through an FFT. The peak comes back either way, so a prove - run yields the same split/merge signal a check run does. -/ + run yields the same split/merge signal a check run does. + + `execOnly` stops after execution + measurement (`proof` is `none` + either way; `suggestedParts` is 1 exactly when the peak fits): the + split loop runs on executions alone, never starting a STARK. -/ def shardProveWithEnv (system : @& AiurSystem) (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) - (ownedBlob : ByteArray) (maxRamBytes : Nat := 0) : + (ownedBlob : ByteArray) (maxRamBytes : Nat := 0) + (execOnly : Bool := false) : Except String ShardProveResult := - shardProveWithEnv' system funIdx envHandle ownedBlob maxRamBytes + shardProveWithEnv' system funIdx envHandle ownedBlob maxRamBytes execOnly @[extern "rs_aiur_system_verify"] opaque verify : @& AiurSystem → @@ -231,6 +243,11 @@ structure ShardResult where error : String peakBytes : Nat weights : ByteArray + /-- 1 when `peakBytes` fits the batch's `maxRamBytes` (or no budget + was given); otherwise the part count the peak model projects will + fit (`AiurSystem::suggested_split_parts`, measured on the record + in-task). -/ + suggestedParts : Nat deriving Inhabited /-- Bytes per packed `weights` row: 32 address + 8 vspan + 8 mult. -/ @@ -257,7 +274,7 @@ private def readU64LE (ba : ByteArray) (off : Nat) : UInt64 := Id.run do @[extern "rs_aiur_toplevel_shard_check_batch"] private opaque shardCheckBatchWithEnv' : @& Bytecode.Toplevel → @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → @& Nat → - @& CommitmentParameters → @& FriParameters → Bool → @& Nat → + @& CommitmentParameters → @& FriParameters → Bool → @& Nat → @& Nat → Except String (Array ShardResult) /-- Check EVERY shard of a partition in one call: rayon over the shard @@ -277,16 +294,23 @@ private opaque shardCheckBatchWithEnv' : @& Bytecode.Toplevel → is bounded by the Rust-side RAM gate (a byte-weighted admission semaphore over estimated per-shard execution RSS vs available system RAM), not by thread count — pass `jobs` only to narrow - CPU use. -/ + CPU use. + + `maxRamBytes > 0` is a per-shard prover-RAM budget: each result's + `suggestedParts` is 1 when its peak fits and the model's projected + part count otherwise, so a caller can cut over-budget shards and + re-batch the parts — the wave loop that audits a partition's split + behavior on executions alone. -/ def shardCheckBatchWithEnv (toplevel : @& Bytecode.Toplevel) (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (shardsBlob : ByteArray) (useBytecode : Bool := false) (jobs : Nat := 0) (commitmentParameters : CommitmentParameters := defaultCommitmentParameters) (friParameters : FriParameters := defaultFriParameters) (profile : Bool := false) (checkConstIdx : Nat := 0) + (maxRamBytes : Nat := 0) : Except String (Array ShardResult) := shardCheckBatchWithEnv' toplevel funIdx envHandle shardsBlob useBytecode - jobs commitmentParameters friParameters profile checkConstIdx + jobs commitmentParameters friParameters profile checkConstIdx maxRamBytes end Bytecode.Toplevel diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index 65ff4b7ce..29b4ab910 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -276,7 +276,8 @@ private opaque checkAddrsWithEnv' : @& Bytecode.Toplevel → through the exact single-claim machinery over task-private data (own witness io, own query record), nothing shared between tasks but the read-only toplevel and env. Returns the FAILURES as - `(addrHex, error)` pairs; empty means all passed. Per-claim + `(batch index as a decimal string, error)` pairs, resolving back to + the caller's label order; empty means all passed. Per-claim outputs/records are not returned — use `checkAddrWithEnv` for a single claim's full result. -/ def checkAddrsWithEnv (toplevel : @& Bytecode.Toplevel) diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 10d57a959..4a2c867c5 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -34,6 +34,7 @@ public import Ix.Meta public import Ix.Store public import Ix.Cli.NameResolve public import Ix.Benchmark.Results +public import Ix.KernelCheck public import Ix.TracingTexray public section @@ -659,6 +660,42 @@ def shardsCover (ixonEnv : Ixon.Env) (shards : Array (Array Address)) : IO Bool IO.println s!"[shards] OK: partition covers all {ixonEnv.consts.size} consts, disjoint" pure ok +/-- Cut `blocks` into contiguous, nonempty, roughly equal-count parts + (`p` clamped to `[2, blocks.size]` — a rejection always needs at + least two parts, and the block list caps how many a cut can + produce). Rows are what the prover-RAM model responds to, and equal + block counts are the measured-best proxy for equal rows + (equal-vspan cuts lost on parts, depth and executions on every env + tried). Shared by the prove split recursion and the check wave + loop. -/ +def cutBlocks (blocks : Array Address) (p : Nat) : Array (Array Address) := + let p := min (max p 2) blocks.size + (Array.range p).map fun i => + blocks.extract (blocks.size * i / p) (blocks.size * (i + 1) / p) + +/-- Measured-peaks blob for the manifest emit: one 8-byte LE value per + shard, in shard order. -/ +def peaksBlob (peaks : Array Nat) : ByteArray := Id.run do + let mut blob := ByteArray.empty + for pk in peaks do + let v := pk.toUInt64 + for b in [0 : 8] do + blob := blob.push (v >>> (8 * b.toUInt64)).toUInt8 + return blob + +/-- Wire encoding shared by the shard batch FFI and the manifest emit: + per entry, a 4-byte LE count followed by the 32-byte addresses. -/ +def addrListsBlob (lists : Array (Array Address)) : ByteArray := Id.run do + let mut blob := ByteArray.empty + for l in lists do + let n := l.size.toUInt32 + blob := blob.push n.toUInt8 + blob := blob.push (n >>> 8).toUInt8 + blob := blob.push (n >>> 16).toUInt8 + blob := blob.push (n >>> 24).toUInt8 + for a in l do blob := blob ++ a.hash + return blob + /-- Whole-partition check as ONE Rust rayon batch: work-stealing across shards, no chunk barriers (measured 2.3–2.5x faster than the per-shard Lean-task scheduler it replaced, whose chunk-of-N full @@ -673,7 +710,9 @@ def shardsCover (ixonEnv : Ixon.Env) (shards : Array (Array Address)) : IO Bool def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) (compiled : Aiur.CompiledToplevel) (useBytecode : Bool) (profileOut : Option String) - (json? : Option (String × String) := none) : IO UInt32 := do + (json? : Option (String × String) := none) + (maxRamBytes : Nat := 0) (outIxes : Option String := none) : + IO UInt32 := do -- The row's peak-rss needs the process-tree RSS sampler running -- (`peakTreeRssBytes` reports 0 otherwise); started before the env -- load so the peak covers the whole run, like `check-rs`. @@ -692,82 +731,138 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) -- at env scale (241 shards × 688k consts) that is ~30 min of setup. -- Each shard's array keeps env-iteration order, identical to what -- the per-shard filter produces, so claim digests are unchanged. - let mut blockToShard : Std.HashMap Address Nat := {} - for (blocks, k) in shards.mapIdx (fun k b => (b, k)) do - for blk in blocks do blockToShard := blockToShard.insert blk k - let mut ownedPerShard : Array (Array Address) := Array.replicate shards.size #[] - for (addr, lc) in ixonEnv.consts do - let some c := lc.get? | continue - match blockToShard.get? (blockAddrOf addr c) with - | some k => ownedPerShard := ownedPerShard.modify k (·.push addr) - | none => pure () - let mut blob := ByteArray.empty - for owned in ownedPerShard do - let n := owned.size.toUInt32 - blob := blob.push n.toUInt8 - blob := blob.push (n >>> 8).toUInt8 - blob := blob.push (n >>> 16).toUInt8 - blob := blob.push (n >>> 24).toUInt8 - for a in owned do blob := blob ++ a.hash - IO.println s!"Typechecking {shards.size} shard(s) in one rayon \ - batch, {jobs} thread(s) (0 = all)" - (← IO.getStdout).flush - let totalConsts := ownedPerShard.foldl (· + ·.size) 0 - let start ← IO.monoMsNow + let ownedFor (waveBlocks : Array (Array Address)) : + Array (Array Address) := Id.run do + let mut blockToShard : Std.HashMap Address Nat := {} + for (blocks, k) in waveBlocks.mapIdx (fun k b => (b, k)) do + for blk in blocks do blockToShard := blockToShard.insert blk k + let mut owned : Array (Array Address) := + Array.replicate waveBlocks.size #[] + for (addr, lc) in ixonEnv.consts do + let some c := lc.get? | continue + match blockToShard.get? (blockAddrOf addr c) with + | some k => owned := owned.modify k (·.push addr) + | none => pure () + return owned -- `check_const`'s queries are what the weight rows are read from; a -- toplevel without it can still check, just not profile. let checkConstIdx := (compiled.getFuncIdx `check_const).getD 0 if profileOut.isSome && (compiled.getFuncIdx `check_const).isNone then IO.eprintln "--profile: no `check_const` in compiled toplevel" - match compiled.bytecode.shardCheckBatchWithEnv funIdx envHandle blob - useBytecode jobs Aiur.defaultCommitmentParameters - Aiur.defaultFriParameters profileOut.isSome checkConstIdx with - | .error e => IO.eprintln s!"shard batch: {e}"; return 1 - | .ok results => - let elapsedMs := (← IO.monoMsNow) - start - let mut failures : Nat := 0 - for k in [:results.size] do - let r := results[k]! - if r.error.isEmpty then + let cutLabeled (label : String) (blocks : Array Address) (p : Nat) : + Array (String × Array Address) := + (cutBlocks blocks p).mapIdx fun i part => (s!"{label}.{i}", part) + -- One loop over execution waves. Wave 0 is the planned partition; + -- with `--max-ram` every over-budget shard is cut into the peak + -- model's suggested part count and the parts re-batched as the next + -- wave, until everything fits or is a single block. Without a + -- budget the FFI answers 1 part everywhere and the loop is a single + -- wave — the plain batch check. Waves after the first never + -- profile: vspans are partition-invariant, so wave 0 already + -- carries every constant's row. + let mut wave : Array (String × Array Address) := + shards.mapIdx fun k b => (s!"{k}", b) + let mut waveNum := 0 + let mut failures : Nat := 0 + let mut failed : Array String := #[] + let mut final : Array (Array Address × Nat) := #[] + let mut totalConsts := 0 + let mut elapsedMs := 0 + while wave.size > 0 do + if waveNum == 0 then + IO.println s!"Typechecking {wave.size} shard(s) in one rayon \ + batch, {jobs} thread(s) (0 = all)" + else + IO.println s!"[wave {waveNum}] re-executing {wave.size} part(s)" + (← IO.getStdout).flush + let ownedPer := ownedFor (wave.map (·.2)) + let profile := profileOut.isSome && waveNum == 0 + let start ← IO.monoMsNow + match compiled.bytecode.shardCheckBatchWithEnv funIdx envHandle + (addrListsBlob ownedPer) useBytecode jobs + Aiur.defaultCommitmentParameters Aiur.defaultFriParameters + profile checkConstIdx maxRamBytes with + | .error e => IO.eprintln s!"shard batch (wave {waveNum}): {e}"; return 1 + | .ok rs => + if waveNum == 0 then + -- The bench row's measured window: the planned partition's + -- batch call, matching `check-rs`. Split waves are audit + -- extras outside the benchmarked engine window. + elapsedMs := (← IO.monoMsNow) - start + totalConsts := ownedPer.foldl (· + ·.size) 0 + let mut next : Array (String × Array Address) := #[] + for j in [:rs.size] do + let r := rs[j]! + let (label, blocks) := wave[j]! let gib := Float.ofNat r.peakBytes / 1073741824.0 - IO.println s!"[shard {k}] ok, projected prover peak {gib} GiB" - else - IO.eprintln s!"[shard {k}] FAILED: {r.error}" - failures := failures + 1 - -- Weight rows are appended once for the whole batch: Rust already - -- reduced each shard's record under its own task, so nothing here - -- holds a record alive. - if let some out := profileOut then - let h ← IO.FS.Handle.mk out .append - for r in results do - h.putStr <| r.foldWeights "" fun acc addrBytes vspan mult => - let addr : Address := ⟨addrBytes⟩ - let name := (ixonEnv.addrToName.get? addr).map (s!" {·}") |>.getD "" - acc ++ s!"{addr} {vspan} {mult}{name}\n" - h.flush - -- One env-keyed results row for `ix bench run --backend aiur-sharded-env`: - -- the measured window is the batch FFI call (env load and blob - -- setup are excluded, matching what the benchmark tracks — the - -- execution engine, not the loader). - if let some (path, key) := json? then - let secs := elapsedMs.toFloat / 1000.0 - let tput := if elapsedMs > 0 - then totalConsts.toFloat * 1000.0 / elapsedMs.toFloat else 0.0 - let peakRss ← TracingTexray.peakTreeRssBytes - let status := if failures == 0 then "ok" else "rejected" - Ix.Benchmark.Results.writeRow path key status - [ ("constants", Lean.toJson totalConsts) - , ("shards", Lean.toJson results.size) - , ("check-time", Ix.Benchmark.Results.jsonRound 3 secs) - , ("throughput", Ix.Benchmark.Results.jsonRound 2 tput) - , ("peak-rss", Lean.toJson peakRss) ] + if !r.error.isEmpty then + IO.eprintln s!"[shard {label}] FAILED: {r.error}" + failures := failures + 1 + failed := failed.push s!"shard {label}: {r.error}" + final := final.push (blocks, r.peakBytes) + else if r.suggestedParts <= 1 then + IO.println s!"[shard {label}] ok, projected prover peak {gib} GiB" + final := final.push (blocks, r.peakBytes) + else if blocks.size <= 1 then + IO.eprintln s!"[shard {label}] peak {gib} GiB over budget and a \ + single block — cannot split" + failures := failures + 1 + failed := failed.push s!"shard {label}: single block over budget" + final := final.push (blocks, r.peakBytes) + else + IO.println s!"[shard {label}] peak {gib} GiB over budget — cut \ + into {r.suggestedParts}" + next := next ++ cutLabeled label blocks r.suggestedParts + -- Weight rows are appended once, from wave 0: Rust already + -- reduced each shard's record under its own task, so nothing + -- here holds a record alive. + if profile then + if let some out := profileOut then + let h ← IO.FS.Handle.mk out .append + for r in rs do + h.putStr <| r.foldWeights "" fun acc addrBytes vspan mult => + let addr : Address := ⟨addrBytes⟩ + let name := (ixonEnv.addrToName.get? addr).map (s!" {·}") |>.getD "" + acc ++ s!"{addr} {vspan} {mult}{name}\n" + h.flush + wave := next + waveNum := waveNum + 1 + if maxRamBytes > 0 then + IO.println s!"[split-audit] {final.size} part(s) from {shards.size} \ + planned shard(s), {waveNum - 1} split wave(s), {failures} failure(s)" + -- The recalibrated partition — what this run actually validated — + -- written as the manifest the next run should start from. + if let some out := outIxes then if failures == 0 then - IO.println s!"All {results.size} shard(s) passed" - return 0 - IO.eprintln s!"{failures} of {results.size} shard(s) FAILED" - -- Under `--json` a kernel rejection is the benchmark's `rejected` - -- exit (the row is already written), same contract as `check-rs`. - return if json?.isSome then Ix.Benchmark.Results.exitRejected else 1 + Ix.KernelCheck.rsShardManifestFromPartitionFFI ixePath + (addrListsBlob (final.map (·.1))) (peaksBlob (final.map (·.2))) out + IO.println s!"[split-audit] recalibrated manifest → {out}" + else + IO.eprintln s!"--out-ixes {out} skipped: {failures} failure(s)" + -- One env-keyed results row for `ix bench run --backend aiur-sharded-env`: + -- the measured window is the wave-0 batch FFI call (env load and + -- blob setup are excluded, matching what the benchmark tracks — the + -- execution engine, not the loader). + if let some (path, key) := json? then + let secs := elapsedMs.toFloat / 1000.0 + let tput := if elapsedMs > 0 + then totalConsts.toFloat * 1000.0 / elapsedMs.toFloat else 0.0 + let peakRss ← TracingTexray.peakTreeRssBytes + let status := if failures == 0 then "ok" else "rejected" + Ix.Benchmark.Results.writeRow path key status + [ ("constants", Lean.toJson totalConsts) + , ("shards", Lean.toJson final.size) + , ("check-time", Ix.Benchmark.Results.jsonRound 3 secs) + , ("throughput", Ix.Benchmark.Results.jsonRound 2 tput) + , ("peak-rss", Lean.toJson peakRss) ] + if failures == 0 then + IO.println s!"All {final.size} shard(s) passed" + return 0 + IO.eprintln s!"{failures} of {final.size} shard(s) FAILED:" + for f in failed do IO.eprintln s!" {f}" + -- Under `--json` a kernel rejection is the benchmark's `rejected` + -- exit (the row is already written), same contract as `check-rs`. + return if json?.isSome then Ix.Benchmark.Results.exitRejected else 1 /-- Run the shard operation over EVERY shard — the whole-partition behavior of `--ixes` with no `--shard` (used by `prove`). Loads the env once. Returns 1 @@ -892,7 +987,9 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do let json? := (p.flag? "json").map fun f => (f.as! String, ((p.flag? "json-name").map (·.as! String)).getD "env") return (← runShardBatchNative manifest ixe - ((p.flag? "jobs").map (·.as! Nat)) compiled useBytecode profileOut json?) + ((p.flag? "jobs").map (·.as! Nat)) compiled useBytecode profileOut json? + (((p.flag? "max-ram").map (·.as! Nat)).getD 0 * 1073741824) + ((p.flag? "out-ixes").map (·.as! String))) | _, _, _ => -- `--jobs N` (N ≠ 1) with an `--ixe` env and no `--claim` takes the -- parallel batch path: one FFI call, rayon over the target list, @@ -928,6 +1025,8 @@ def checkCmd : Cli.Cmd := `[Cli| "jobs" : Nat; "Parallelism. With --ixes (no --shard): max shards checked concurrently (default: all at once). With --ixe alone and N ≠ 1: check the targeted constants on N Rust threads (0 = all cores), each claim over its own private record — peak RAM is bounded by N in-flight claim closures." "json" : String; "With --ixes (no --shard): append one env-keyed results row (see Ix.Benchmark.Results) for the batch to this file — check-time, throughput, peak-rss, constants, shards. Used by `ix bench run --backend aiur-sharded-env`." "json-name" : String; "Row key for the --json row (default: `env`)." + "max-ram" : Nat; "Per-shard prover-RAM budget, GiB (with --ixes, no --shard): after the batch, cut every shard whose projected prover peak exceeds the budget into the peak model's suggested part count and re-batch the parts, wave by wave, until everything fits. Executions only — the cheap audit of a partition's split behavior; the wave count is the recursion depth. Omit for a plain check." + "out-ixes" : String; "With --max-ram: write the recalibrated partition — the block lists the wave loop actually validated, splits included — as a `.ixes` manifest to this path. Skipped if any shard failed. The manifest the next run of this env should start from." ARGS: ...names : String; "Fully-qualified Lean.Name(s) to check. With none, iterate every named constant in the env (sorted)." diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index 4efa86a7c..2daa0f7d9 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -105,55 +105,75 @@ def proveOne (aiurSystem : Aiur.AiurSystem) IO.println (toString proofAddr) return 0 -/-- Prove the constants owned by `blocks` as ONE shard, splitting and - recursing whenever the executed record's projected prover peak - exceeds the budget. +/-- Prove the constants owned by `blocks` as ONE shard, cutting it into + the peak model's suggested part count whenever the executed record's + projected prover peak exceeds the budget, and recursing on any part + that still misses. + + Cuts are contiguous equal-block-count runs: rows are what the RAM + model responds to, and equal-cumulative-vspan cuts measured worse + on every axis (parts, depth, executions) across a synthetic + fixture, init, and lean — vspan tracks time, not rows. A shard is only a plan, never part of a statement: its claim is `checkEnv(ownedRoot, asmRoot)`, a pure function of `(env, owned)` - with the frontier recomputed from the owned set. So halving `blocks` - yields two claims exactly as valid as the parent's — each half's - grown frontier is discharged by its sibling — and the split costs - only the parent's execution, the cheap half of the run. Splitting on - BLOCKS rather than constants is what keeps mutual-recursion groups - intact, since every constant maps to exactly one block. + with the frontier recomputed from the owned set. So cutting `blocks` + yields claims exactly as valid as the parent's — each part's grown + frontier is discharged by its siblings — and the cut costs only the + parent's execution, the cheap half of the run. Splitting on BLOCKS + rather than constants is what keeps mutual-recursion groups intact, + since every constant maps to exactly one block. + + The suggested count is optimistic — parts re-execute dependencies + shared across the cut, and equal block counts are not equal row + counts — so each part is gated on its own executed record and + re-cut if it misses. That bias is deliberate: an under-cut costs + one cheap re-execution, an over-cut pays the per-proof floor on + every extra part for the life of the partition. - Returns the block sets actually proven, in proof order: the parent's - own when it fit, otherwise its descendants'. That is the partition - the run really produced, which is what an updated manifest has to - describe once the whole pipeline is done. -/ + Returns the parts actually proven, in proof order, each with its + measured projected prover peak: the parent's own when it fit, + otherwise its descendants'. That is the partition the run really + produced — what the corrected manifest describes, peaks included. -/ partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) (ixonEnv : Ixon.Env) (aiurSystem : Aiur.AiurSystem) - (funIdx : Aiur.Bytecode.FunIdx) (maxRamBytes : Nat) (label : String) - (blocks : Array Address) : IO (Except String (Array (Array Address))) := do + (funIdx : Aiur.Bytecode.FunIdx) (maxRamBytes : Nat) + (execOnly : Bool) (label : String) + (blocks : Array Address) : + IO (Except String (Array (Array Address × Nat))) := do let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks ixonEnv blocks let mut blob := ByteArray.empty for a in owned do blob := blob ++ a.hash IO.println s!"Proving {label} ({blocks.size} blocks, {owned.size} consts)" (← IO.getStdout).flush - match aiurSystem.shardProveWithEnv funIdx envHandle blob maxRamBytes with + match aiurSystem.shardProveWithEnv funIdx envHandle blob maxRamBytes + execOnly with | .error e => return .error s!"{label}: shardProveWithEnv error: {e}" - | .ok { claimBytes, proof, peakBytes } => + | .ok { claimBytes, proof, peakBytes, suggestedParts } => let gib := Float.ofNat peakBytes / 1073741824.0 match proof with | none => + -- Exec-only leaf: the peak fit (parts = 1), there is just no + -- STARK behind it. The partition bookkeeping is identical. + if execOnly && suggestedParts <= 1 then + IO.println s!"[{label}] prover peak {gib} GiB (exec-only)" + return .ok #[(blocks, peakBytes)] -- A single block is the atom the kernel checks together; there is -- no smaller shard to fall back to. if blocks.size <= 1 then return .error s!"{label}: projected prover peak {gib} GiB exceeds \ the budget and the shard is a single block — raise --max-ram" - let mid := blocks.size / 2 - IO.println s!"[{label}] peak {gib} GiB over budget — splitting \ - {blocks.size} blocks into {mid} + {blocks.size - mid}" - match ← proveBlocksWithinBudget envHandle ixonEnv aiurSystem funIdx - maxRamBytes s!"{label}.0" (blocks.extract 0 mid) with - | .error e => return .error e - | .ok lo => + let cut := Ix.Cli.CheckCmd.cutBlocks blocks suggestedParts + IO.println s!"[{label}] peak {gib} GiB over budget — cutting \ + {blocks.size} blocks into {cut.size} parts" + let mut proven : Array (Array Address × Nat) := #[] + for i in [0 : cut.size] do match ← proveBlocksWithinBudget envHandle ixonEnv aiurSystem funIdx - maxRamBytes s!"{label}.1" (blocks.extract mid blocks.size) with + maxRamBytes execOnly s!"{label}.{i}" cut[i]! with | .error e => return .error e - | .ok hi => return .ok (lo ++ hi) + | .ok parts => proven := proven ++ parts + return .ok proven | some proof => IO.println s!"[{label}] prover peak {gib} GiB" -- Rust returns the canonical CheckEnv claim's wire bytes; deserialize @@ -166,24 +186,25 @@ partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) IO.println (toString proofAddr) - return .ok #[blocks] + return .ok #[(blocks, peakBytes)] /-- Prove shard `shardK` of the partition, splitting it as needed. Returns the block sets actually proven for that shard. -/ def runShardProveNative (envHandle : Aiur.EnvHandle) (ixonEnv : Ixon.Env) (shards : Array (Array Address)) (shardK : Nat) (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) - (maxRamBytes : Nat) : IO (Except String (Array (Array Address))) := do + (maxRamBytes : Nat) (execOnly : Bool) : + IO (Except String (Array (Array Address × Nat))) := do match shards[shardK]? with | none => return .error s!"shard {shardK} out of range (0..{shards.size})" | some blocks => let funIdx := compiled.getFuncIdx `verify_claim |>.get! proveBlocksWithinBudget envHandle ixonEnv aiurSystem funIdx maxRamBytes - s!"shard {shardK}" blocks + execOnly s!"shard {shardK}" blocks /-- Report the partition a prove run actually produced against the one its manifest planned. They differ exactly when a shard was split. -/ -def reportPartition (proven : Array (Array Address)) (planned : Nat) : IO Unit := do +def reportPartition (proven : Array (Array Address × Nat)) (planned : Nat) : IO Unit := do if proven.size == planned then IO.println s!"[prove] {proven.size} shard(s) proven, partition unchanged" else @@ -192,11 +213,27 @@ def reportPartition (proven : Array (Array Address)) (planned : Nat) : IO Unit : skip the splits next run" def runProveCmd (p : Cli.Parsed) : IO UInt32 := do + -- Streamed `[texray] : ── RAM Δ/peak` lines on stderr as + -- each `aiur/` / `stark/` span closes: the per-phase wall + RSS + -- breakdown (execute vs witness vs STARK) of every prove in the run. + if p.hasFlag "texray" then TracingTexray.init {} let keepGoing := p.hasFlag "keep-going" -- Same units as `ix shard --max-ram`: the per-shard prover budget the -- partition was sized against, re-checked here against each shard's - -- measured peak. 0 = unchecked. + -- measured peak. 0 = detect (85% of `MemAvailable`, the check batch's + -- gate policy — see `shardProveWithEnv`). let maxRamBytes := ((p.flag? "max-ram").map (·.as! Nat)).getD 0 * 1073741824 + let execOnly := p.hasFlag "exec-only" + let outIxes := (p.flag? "out-ixes").map (·.as! String) + -- Both `--ixes` branches end the same way: the partition the run + -- actually proved, written as the manifest to start the next run from. + let emitCorrected (ixe : String) (partition : Array (Array Address × Nat)) : + IO Unit := do + if let some out := outIxes then + Ix.KernelCheck.rsShardManifestFromPartitionFFI ixe + (Ix.Cli.CheckCmd.addrListsBlob (partition.map (·.1))) + (Ix.Cli.CheckCmd.peaksBlob (partition.map (·.2))) out + IO.println s!"[prove] corrected manifest → {out}" let ixePath : Option String := (p.flag? "ixe").map (·.as! String) let claimHex : Option String := (p.flag? "claim").map (·.as! String) let names := (p.variableArgsAs! String).toList @@ -219,10 +256,17 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 | .ok h => pure h match ← runShardProveNative envHandle ixonEnv shards k aiurSystem - compiled maxRamBytes with + compiled maxRamBytes execOnly with | .error e => IO.eprintln e; return 1 | .ok parts => - reportPartition parts shards.size + -- A single-shard run plans exactly one shard, not the whole + -- partition. + reportPartition parts 1 + -- The corrected whole partition: the plan with shard k replaced + -- by the parts this run actually proved. + emitCorrected ixe + ((shards.extract 0 k).map (·, 0) ++ parts + ++ (shards.extract (k + 1) shards.size).map (·, 0)) return 0 | some ixe, some manifest, none => -- IxVM-native all-shards prove. Same envHandle reused across @@ -236,16 +280,23 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do -- Accumulate the partition the run actually produced. Splits stay -- in this process, so the manifest describing them is written -- once at the end rather than rewritten per split. - let mut proven : Array (Array Address) := #[] - let mut rc : UInt32 := 0 + let mut proven : Array (Array Address × Nat) := #[] + let mut failed : Array (Nat × String) := #[] for k in [0 : shards.size] do match ← runShardProveNative envHandle ixonEnv shards k aiurSystem - compiled maxRamBytes with - | .error e => IO.eprintln e; rc := 1 + compiled maxRamBytes execOnly with + | .error e => IO.eprintln e; failed := failed.push (k, e) | .ok parts => proven := proven ++ parts - if rc == 0 then reportPartition proven shards.size - let _ := manifest - pure rc + if failed.isEmpty then + reportPartition proven shards.size + emitCorrected ixe proven + return 0 + IO.eprintln s!"[prove] {failed.size} of {shards.size} shard(s) FAILED:" + for (k, e) in failed do + IO.eprintln s!" shard {k}: {e}" + if let some out := outIxes then + IO.eprintln s!"--out-ixes {out} skipped: {failed.size} failure(s)" + return 1 | _, _, _ => Ix.Cli.CheckCmd.forEachClaim ixePath claimHex names keepGoing "prove" false runOne @@ -258,11 +309,14 @@ def proveCmd : Cli.Cmd := `[Cli| FLAGS: "keep-going"; "Continue past failures and report them at the end instead of halting on the first." + "texray"; "Stream per-phase `[texray]` timing/RSS lines (execute, witness, STARK stages) to stderr as each span closes." "ixe" : String; "Path to a serialized `.ixe` env. When set, the binary reads the env from disk instead of using the compiled-in Lean env." "claim" : String; "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, proves the persisted claim against the `--ixe` env (single proof, skips per-const iteration)." "ixes" : String; "Path to a `.ixes` shard manifest (with --ixe). With --shard K: prove shard K. Without --shard: prove every shard in the partition." "shard" : Nat; "0-based shard index K (with --ixes and --ixe): prove that one shard's CheckEnv claim." - "max-ram" : Nat; "Per-shard prover-RAM budget, GiB — normally the same value the partition was sized with (`ix shard --max-ram`). Each shard is executed, its projected prover peak measured on the resulting record, and the proof attempted only if it fits; an over-budget shard is reported (split it and re-run) instead of being taken into the FFT phases that would exhaust the box. Omit to prove unconditionally." + "out-ixes" : String; "Write the partition this run actually proved — splits included — as a `.ixes` manifest to this path: the manifest `ix verify --ixes` checks these proofs against, and the one the next run of this env should start from. Skipped if any shard failed." + "exec-only"; "Execute each shard and measure its projected prover peak, splitting over-budget shards as usual, but never start a STARK. The cheap way to audit a partition's split behavior at scale." + "max-ram" : Nat; "Per-shard prover-RAM budget, GiB — normally the same value the partition was sized with (`ix shard --max-ram`). Each shard is executed, its projected prover peak measured on the resulting record, and the proof attempted only if it fits; an over-budget shard is cut into the part count the peak model projects will fit, and each part re-gated, instead of being taken into the FFT phases that would exhaust the box. Omit to detect: 85% of the machine's available RAM." ARGS: ...names : String; "Fully-qualified Lean.Name(s) to prove. With none, iterate every named constant in the env (sorted)." diff --git a/Ix/KernelCheck.lean b/Ix/KernelCheck.lean index d403997a5..bd3451f53 100644 --- a/Ix/KernelCheck.lean +++ b/Ix/KernelCheck.lean @@ -207,6 +207,23 @@ opaque rsShardEnvStaticFFI : @& String → -- .ixes output path ("" = skip) IO Unit +/-- FFI: write a `.ixes` manifest for an EXPLICIT partition — the block + lists a run actually produced (splits included) rather than a + planner's output. `shardsBlob`: per shard, a 4-byte LE block count + followed by that many 32-byte block addresses; every env block must + appear in exactly one shard. Own sizes, foreign blocks, + cross-ingress and assumption roots are recomputed from the env's + static profile; each shard's `measured_peak_bytes` comes from + `peaksBlob` (empty, or one 8-byte LE peak per shard in order). + Prints the manifest summary to stderr. -/ +@[extern "rs_shard_manifest_from_partition"] +opaque rsShardManifestFromPartitionFFI : + @& String → -- .ixe path + @& ByteArray → -- partition blob + @& ByteArray → -- measured-peaks blob + @& String → -- .ixes output path + IO Unit + /-- FFI: dump the static block-level reference graph of a `.ixe` as text: `block ` per ingress unit and `edge ` per deduped claim-walk edge at block diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 14ff4d268..8e86f8741 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -302,6 +302,54 @@ impl AiurSystem { } } + /// Smallest power-of-two part count whose projected per-part peak + /// fits `max_bytes`, assuming the record's rows divide evenly across + /// parts. The gadget circuits keep their constant heights — they are + /// the same size in every shard and are most of the model's fixed + /// floor, which dividing cannot shrink. + /// + /// The estimate is optimistic: a part re-executes dependencies shared + /// across the cut, so its real rows exceed its 1/n share. A caller + /// splitting on this number must still gate each part on its own + /// executed record and re-split the ones that miss. Optimism is the + /// right bias — an under-split costs one cheap re-execution, while an + /// over-split pays the per-proof floor on every extra part forever. + /// + /// Returns 1 when the record already fits. + pub fn suggested_split_parts( + &self, + record: &QueryRecord, + max_bytes: usize, + ) -> usize { + let record_bytes = crate::execute::record_retained_bytes(record); + let mut parts = 1usize; + // A shard still over budget at 2^20 parts is not splittable by row + // count; stop rather than search forever. + while parts < (1 << 20) { + let peak = self + .peak_prove_bytes_by( + |_, ct| match ct { + CircuitType::Function { idx } => { + record.function_queries[*idx].len().div_ceil(parts) + }, + CircuitType::Memory { width } => record + .memory_queries + .get(width) + .map_or(0, |m| m.len().div_ceil(parts)), + CircuitType::Bytes1 => 256, + CircuitType::Bytes2 => 65536, + }, + record_bytes / parts, + ) + .peak; + if peak <= max_bytes { + break; + } + parts *= 2; + } + parts + } + /// Prove an execution that has ALREADY happened: everything from the /// witness phase on, over a record the caller hands across. /// @@ -432,8 +480,11 @@ impl AiurSystem { /// not estimated from serialized bytes, so an over-budget shard is /// caught in the gap between execution and the witness phase — before /// the LDE/commit/FRI phases that would actually exhaust the box. The - /// record is dropped rather than proven and the peak comes back as - /// `Err(peak)`, which is the number a caller splits the shard against. + /// record is dropped rather than proven and `Err((peak, parts))` + /// comes back: the measured peak, and the part count + /// [`Self::suggested_split_parts`] projects will fit — computed here + /// because this is the last moment the record exists to read counts + /// from. /// /// On success the peak is returned too: proving a shard measures it for /// free, so a prove run yields the same split/merge signal a check run @@ -450,7 +501,7 @@ impl AiurSystem { io_buffer: &mut IOBuffer, executor: F, max_bytes: Option, - ) -> Result<(Vec, AiurProof, usize), usize> + ) -> Result<(Vec, AiurProof, usize), (usize, usize)> where F: FnOnce( &Toplevel, @@ -467,14 +518,55 @@ impl AiurSystem { drop(_g); let peak = self.peak_prove_bytes(&query_record).peak; - if max_bytes.is_some_and(|max| peak > max) { - return Err(peak); + if let Some(max) = max_bytes + && peak > max + { + return Err((peak, self.suggested_split_parts(&query_record, max))); } let (claim, proof) = self.prove_from_execution(fun_idx, input, io_buffer, query_record, &output); Ok((claim, proof, peak)) } + /// Execute-only twin of [`Self::prove_ixvm_within_budget`]: run the + /// execution, measure the record's projected peak, and go no further. + /// + /// Returns `(peak, parts)`: `parts` is 1 when the peak fits + /// `max_bytes` (or no budget is given), else the split count + /// [`Self::suggested_split_parts`] projects will fit. This is the dry + /// leg of the split loop — sizing or auditing a partition costs + /// executions only, never a STARK. + pub fn execute_peak_ixvm( + &self, + fun_idx: FunIdx, + input: &[G], + io_buffer: &mut IOBuffer, + executor: F, + max_bytes: Option, + ) -> (usize, usize) + where + F: FnOnce( + &Toplevel, + FunIdx, + Vec, + &mut IOBuffer, + ) -> Result<(QueryRecord, Vec), ExecError>, + { + let _g = tracing::info_span!("aiur/execute_ixvm").entered(); + let (query_record, _output) = + executor(&self.toplevel, fun_idx, input.to_vec(), io_buffer) + .expect("IxVM-native Aiur execution failed during execute_peak"); + drop(_g); + let peak = self.peak_prove_bytes(&query_record).peak; + let parts = match max_bytes { + Some(max) if peak > max => { + self.suggested_split_parts(&query_record, max) + }, + _ => 1, + }; + (peak, parts) + } + #[inline] pub fn verify( &self, diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 20f5491c5..76ea845e9 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -853,12 +853,14 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( fri_parameters: LeanAiurFriParameters>, profile: bool, check_const_idx: LeanNat>, + max_ram_bytes: LeanNat>, ) -> LeanExcept { use rayon::prelude::*; let toplevel = decode_toplevel(&toplevel_obj); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); let jobs = lean_unbox_nat_as_usize(jobs.inner()); let check_const_idx = lean_unbox_nat_as_usize(check_const_idx.inner()); + let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner()); let mut shards: Vec> = Vec::new(); { let bytes = shards_blob.as_bytes(); @@ -924,7 +926,7 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( max as f64 / gib, ); } - let check_batch = || -> Vec<(String, usize, Vec)> { + let check_batch = || -> Vec<(String, usize, Vec, usize)> { shards .par_iter() .zip(estimates.par_iter()) @@ -934,7 +936,7 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness( env, owned, ) { - Err(e) => (format!("witness build: {e}"), 0, Vec::new()), + Err(e) => (format!("witness build: {e}"), 0, Vec::new(), 1), Ok((_claim, input, mut io_buffer)) => match dispatch_execute( &toplevel, fun_idx, @@ -943,11 +945,11 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( use_bytecode, profile, ) { - Err(e) => (e, 0, Vec::new()), - // Both reductions happen here, while the record is still - // owned by this task: it is dropped before `gate.release`, - // so admission keeps bounding peak RSS by the shards in - // flight rather than by the whole partition. + Err(e) => (e, 0, Vec::new(), 1), + // All three reductions happen here, while the record is + // still owned by this task: it is dropped before + // `gate.release`, so admission keeps bounding peak RSS by + // the shards in flight rather than by the whole partition. Ok((record, _output)) => { let peak = system.peak_prove_bytes(&record).peak; let weights = if profile { @@ -955,7 +957,12 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( } else { Vec::new() }; - (String::new(), peak, weights) + let parts = if max_ram_bytes > 0 && peak > max_ram_bytes { + system.suggested_split_parts(&record, max_ram_bytes) + } else { + 1 + }; + (String::new(), peak, weights, parts) }, }, }; @@ -976,11 +983,12 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( pool.install(check_batch) }; let arr = LeanArray::alloc(results.len()); - for (i, (err, peak, weights)) in results.iter().enumerate() { + for (i, (err, peak, weights, parts)) in results.iter().enumerate() { let row = LeanAiurShardResult::alloc(0); row.set_obj(0, LeanString::new(err)); row.set_obj(1, LeanOwned::box_usize(*peak)); row.set_obj(2, LeanByteArray::from_bytes(weights)); + row.set_obj(3, LeanOwned::box_usize(*parts)); arr.set(i, row); } LeanExcept::ok(arr) @@ -1113,12 +1121,19 @@ extern "C" fn rs_aiur_system_prove_addr_with_env( /// `/proc/meminfo` disables the check rather than guessing at it. /// /// Over budget, the record is dropped and `proof` comes back as `none` -/// with the measured `peakBytes`. That is a RESULT, not an error: the -/// caller's answer is to split the shard and prove the halves, and it -/// needs the peak to decide. Learning this here costs one execution -/// instead of an OOM part-way through an FFT. +/// with the measured `peakBytes` and `suggestedParts` — the part count +/// the peak model projects will fit the budget +/// ([`AiurSystem::suggested_split_parts`], measured on the record while +/// it still exists). That is a RESULT, not an error: the caller's +/// answer is to cut the shard into that many parts and prove those. +/// Learning it here costs one execution instead of an OOM part-way +/// through an FFT. `suggestedParts` is `1` whenever the prove ran. /// -/// Returns `(claimBytes, proof?, peakBytes)`. The final IO buffer is +/// `exec_only` stops after execution + measurement: `proof` is `none` +/// either way, and `suggestedParts` is 1 exactly when the peak fits — +/// the split loop runs on executions alone, no STARK ever starts. +/// +/// Returns `(claimBytes, proof?, peakBytes, suggestedParts)`. The final IO buffer is /// deliberately NOT returned: it is the shard's whole ingested byte /// scope, both Lean callers discarded it, and marshalling it back is /// pure cost on the largest buffers in the system. @@ -1132,6 +1147,7 @@ extern "C" fn rs_aiur_system_shard_prove_with_env( >, owned_blob: LeanByteArray>, max_ram_bytes: LeanNat>, + exec_only: bool, ) -> LeanExcept { let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner()); @@ -1158,23 +1174,36 @@ extern "C" fn rs_aiur_system_shard_prove_with_env( } else { available_ram_bytes().map(|b| b / 100 * 85) }; - let proved = aiur_system_obj.get().prove_ixvm_within_budget( - fun_idx, - &input, - &mut io_buffer, - // The prove path never profiles. - |toplevel, fun_idx, input, io_buffer| { - ixvm_codegen::aiur_ixvm_runner::execute_ixvm( - toplevel, fun_idx, input, io_buffer, false, - ) - }, - budget, - ); - let (proof, peak) = match proved { - Ok((_aiur_claim_arr, proof, peak)) => (LeanOption::some( - LeanExternal::alloc(&AIUR_PROOF_CLASS, proof), - ), peak), - Err(peak) => (LeanOption::none(), peak), + // The prove path never profiles. + let executor = |toplevel: &_, fun_idx, input, io_buffer: &mut _| { + ixvm_codegen::aiur_ixvm_runner::execute_ixvm( + toplevel, fun_idx, input, io_buffer, false, + ) + }; + let (proof, peak, parts) = if exec_only { + // Execute + measure, no STARK: `parts` is 1 exactly when the peak + // fits, so the caller's split loop drives off it unchanged. + let (peak, parts) = aiur_system_obj.get().execute_peak_ixvm( + fun_idx, + &input, + &mut io_buffer, + executor, + budget, + ); + (LeanOption::none(), peak, parts) + } else { + match aiur_system_obj.get().prove_ixvm_within_budget( + fun_idx, + &input, + &mut io_buffer, + executor, + budget, + ) { + Ok((_aiur_claim_arr, proof, peak)) => (LeanOption::some( + LeanExternal::alloc(&AIUR_PROOF_CLASS, proof), + ), peak, 1), + Err((peak, parts)) => (LeanOption::none(), peak, parts), + } }; drop(io_buffer); @@ -1184,6 +1213,7 @@ extern "C" fn rs_aiur_system_shard_prove_with_env( result.set_obj(0, LeanByteArray::from_bytes(&claim_bytes)); result.set_obj(1, proof); result.set_obj(2, LeanOwned::box_usize(peak)); + result.set_obj(3, LeanOwned::box_usize(parts)); LeanExcept::ok(result) } diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index a71a167d7..3c6f9d794 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -41,8 +41,8 @@ use lean_ffi::object::LeanNat; use rustc_hash::FxHashMap; use lean_ffi::object::{ - LeanArray, LeanBool, LeanBorrowed, LeanIOResult, LeanList, LeanOption, - LeanOwned, LeanProd, LeanRef, LeanString, + LeanArray, LeanBool, LeanBorrowed, LeanByteArray, LeanIOResult, LeanList, + LeanOption, LeanOwned, LeanProd, LeanRef, LeanString, }; use crate::lean::LeanIxCheckError; @@ -2377,6 +2377,106 @@ pub extern "C" fn rs_shard_env_static( } } +/// FFI: write a `.ixes` manifest describing an EXPLICIT partition — the +/// block lists a prove run actually produced (splits included), so the +/// emitted manifest is the one `ix verify --ixes` can check the run's +/// proofs against, and the one that seeds the next run with a +/// partition that already fits. +/// +/// `shards_blob` encodes, per shard, a 4-byte LE block count followed +/// by that many 32-byte block addresses. Every profile block must +/// appear in EXACTLY one shard: a prove partition covers the env by +/// construction (splits partition their parent), so a gap or duplicate +/// here is an input error, not a policy choice. +/// +/// `peaks_blob`: empty, or one 8-byte LE measured prover peak per +/// shard in shard order — the run's `peak_prove_bytes` measurements, +/// recorded on each manifest shard for schedulers to bin-pack on. +#[allow(clippy::cast_possible_truncation)] // block/shard ids are u32 by construction +#[unsafe(no_mangle)] +pub extern "C" fn rs_shard_manifest_from_partition( + env_path: LeanString>, + shards_blob: LeanByteArray>, + peaks_blob: LeanByteArray>, + out_path: LeanString>, +) -> LeanIOResult { + let path = env_path.to_string(); + let out = out_path.to_string(); + let env = match IxonEnv::get_anon_mmap(std::path::Path::new(&path)) { + Ok(e) => e, + Err(e) => { + return LeanIOResult::error_string(&format!( + "rs_shard_manifest_from_partition: failed to load {path}: {e}" + )); + }, + }; + let profile = static_block_profile(&env); + let block_id: FxHashMap = profile + .blocks() + .iter() + .enumerate() + .map(|(i, b)| (b.addr.clone(), i as u32)) + .collect(); + let bytes = shards_blob.as_bytes(); + let mut shard_of = vec![u32::MAX; profile.num_blocks()]; + let mut num_shards = 0usize; + let mut off = 0usize; + while off < bytes.len() { + if off + 4 > bytes.len() { + return LeanIOResult::error_string("shards_blob: truncated count"); + } + let n = + u32::from_le_bytes(bytes[off..off + 4].try_into().unwrap()) as usize; + off += 4; + if off + n * 32 > bytes.len() { + return LeanIOResult::error_string("shards_blob: truncated addresses"); + } + for c in bytes[off..off + n * 32].chunks_exact(32) { + let addr = Address::from_slice(c).unwrap(); + let Some(&b) = block_id.get(&addr) else { + return LeanIOResult::error_string(&format!( + "shard {num_shards}: block {} not in the env's block profile", + addr.hex() + )); + }; + if shard_of[b as usize] != u32::MAX { + return LeanIOResult::error_string(&format!( + "block {} appears in shards {} and {num_shards}", + addr.hex(), + shard_of[b as usize] + )); + } + shard_of[b as usize] = num_shards as u32; + } + off += n * 32; + num_shards += 1; + } + let uncovered = shard_of.iter().filter(|&&s| s == u32::MAX).count(); + if uncovered > 0 { + return LeanIOResult::error_string(&format!( + "partition covers {} of {} blocks ({uncovered} missing)", + profile.num_blocks() - uncovered, + profile.num_blocks() + )); + } + let peaks: Vec = peaks_blob + .as_bytes() + .chunks_exact(8) + .map(|c| u64::from_le_bytes(c.try_into().unwrap())) + .collect(); + match ix_kernel::shard::shard_manifest_explicit( + &profile, &shard_of, num_shards, &peaks, &out, + ) { + Ok(summary) => { + eprintln!("[shard-manifest] {out}: {summary}"); + LeanIOResult::ok(LeanOwned::box_usize(0)) + }, + Err(e) => LeanIOResult::error_string(&format!( + "rs_shard_manifest_from_partition: {e}" + )), + } +} + /// FFI: dump the static block-level reference graph of a `.ixe` as text — /// `block ` per ingress unit (a Muts block or a /// standalone constant) and `edge ` per deduped diff --git a/crates/ffi/src/lean.rs b/crates/ffi/src/lean.rs index fbcdc5519..58e574d2f 100644 --- a/crates/ffi/src/lean.rs +++ b/crates/ffi/src/lean.rs @@ -294,10 +294,10 @@ lean_ffi::lean_inductive! { LeanAiurProveResult [ { num_obj: 4 } ]; // claimBytes, proof, ioData, ioMap LeanAiurProveEnvResult [ { num_obj: 4 } ]; - // error, peakBytes, weights - LeanAiurShardResult [ { num_obj: 3 } ]; - // claimBytes, proof, peakBytes - LeanAiurShardProveResult [ { num_obj: 3 } ]; + // error, peakBytes, weights, suggestedParts + LeanAiurShardResult [ { num_obj: 4 } ]; + // claimBytes, proof, peakBytes, suggestedParts + LeanAiurShardProveResult [ { num_obj: 4 } ]; // --- Block / comparison types --- diff --git a/crates/kernel/src/shard.rs b/crates/kernel/src/shard.rs index c06d1ae9a..7f1ef1c80 100644 --- a/crates/kernel/src/shard.rs +++ b/crates/kernel/src/shard.rs @@ -1278,6 +1278,11 @@ pub struct ShardInfo { /// root over the foreign part of the shard's static reference closure. `None` /// until populated by the env-aware layer (the pure partitioner has no `Env`). pub assumption_root: Option
, + /// Measured projected prover peak of this shard's executed record + /// (`AiurSystem::peak_prove_bytes`), recorded when the manifest was + /// emitted from a run that executed the shard; 0 = unmeasured (planner + /// output). The scheduling signal: STARK prove wall is ~linear in it. + pub measured_peak_bytes: u64, } /// The sharding manifest: the partition plus its cost metrics. Assumption-tree @@ -1345,6 +1350,7 @@ impl ShardManifest { foreign_blocks, cross_ingress, assumption_root: None, + measured_peak_bytes: 0, }); } ShardManifest { @@ -1434,6 +1440,12 @@ impl ShardManifest { }, None => out.push(0), } + // Trailing measured-peaks section (same older-readers-ignore contract + // as the tree): presence byte, then one u64 LE per shard in order. + out.push(1); + for sh in &self.shards { + out.extend_from_slice(&sh.measured_peak_bytes.to_le_bytes()); + } out } @@ -1462,6 +1474,7 @@ impl ShardManifest { foreign_blocks, cross_ingress, assumption_root, + measured_peak_bytes: 0, }); } // Optional trailing tree section. Absent (end-of-input) on pre-tree @@ -1471,6 +1484,12 @@ impl ShardManifest { } else { None }; + // Optional trailing measured-peaks section; absent on older manifests. + if c.pos < c.buf.len() && c.u8()? == 1 { + for sh in &mut shards { + sh.measured_peak_bytes = c.u64()?; + } + } // The tree is the aggregation plan: a leaf set that is not exactly the // shard id set (each id once) would silently drop or duplicate proven // shards in the fold, so a manifest carrying such a tree is invalid. @@ -1885,6 +1904,42 @@ pub fn shard_esp( )) } +/// Write a `.ixes` manifest for an EXPLICIT shard assignment — the +/// partition a prove run actually produced (splits included) rather +/// than a planner's output. Same manifest construction as +/// [`shard_static`]'s tail: [`ShardManifest::build`] recomputes +/// own sizes, foreign blocks and cross-ingress from the profile, and +/// each shard's assumption root is the canonical merkle root of its +/// foreign blocks. No aggregation tree is attached (consumers fall +/// back to the flat tree-fold); heartbeat figures carry whatever proxy +/// the profile was built with (serialized size, on the static path). +/// `peaks` (empty, or one measured prover-peak per shard in order) +/// fills each shard's `measured_peak_bytes` — the run's measurement +/// riding along for schedulers to bin-pack on. +pub fn shard_manifest_explicit( + profile: &BlockProfile, + shard_of: &[u32], + num_shards: usize, + peaks: &[u64], + out_path: &str, +) -> Result { + if !peaks.is_empty() && peaks.len() != num_shards { + return Err(format!( + "measured peaks: {} values for {num_shards} shards", + peaks.len() + )); + } + let mut manifest = ShardManifest::build(profile, shard_of, num_shards); + for (i, shard) in manifest.shards.iter_mut().enumerate() { + shard.assumption_root = + ixon::merkle::merkle_root_canonical(&shard.foreign_blocks); + shard.measured_peak_bytes = peaks.get(i).copied().unwrap_or(0); + } + std::fs::write(out_path, manifest.to_bytes()) + .map_err(|e| format!("write {out_path}: {e}"))?; + Ok(manifest.summary()) +} + /// Like [`shard_esp`] but sized to a per-shard Zisk **cycle** budget /// (`max_cycles`) rather than a fixed shard count: grows `N` until the heaviest /// splittable shard fits the budget (see [`partition_for_cycle_cap`]). Use From 7de7a7be03b5996d297c2488e795f4829037deda Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Fri, 28 Aug 2026 15:38:47 +0000 Subject: [PATCH 08/44] aiur: quality pass, --ram-budget semantics, settled seed sizing MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Quality/dedup across the splitting and manifest work: GatedProve (Proved/Split/Measured) replaces the Result whose Err arm meant success under exec_only; one raw_of record->rows mapping serves the peak model and the split suggester; detected_ram_budget() carries the 85% policy once, on the kernel's RAM_USABLE_FRAC; decode_addr_lists uses Address::unpack and the blob encoders use toLEBytes; pure helpers are structural folds. Ownership is assigned in ONE env pass per run (ownedConstsPer) with split parts inheriting their parent's constants (partitionOwned) — removing a full env rescan per shard and per split node (~1 h of setup at Mathlib scale). The manifest emit takes the caller's live EnvHandle; the measured-peaks section is presence-gated, strictly validated, and read back by summary(). The uncorrelated Lean RAM projection (projectedProverBytes) is deleted: predicted 135/258/462 GiB where measured RSS was 278/229/265, while the Rust three-phase model tracked +1.2-4.5%. The check audit's budget flag is --ram-budget: it names the destination prove box the partition is destined for, which the audit machine cannot detect — unlike ix prove's --max-ram, which defends the local box and detects 85% of MemAvailable when omitted. gibBytes/toGib live in Ix/Common. Seed sizing settles on 20,000x env bytes against 2/3 of the budget, Mathlib-class-normative: amplification is env-dependent (init 12.5-14k, FLT 19.6k, Mathlib 20.2-21.7k) and Mathlib's shape is the common case for real Lean libraries — a 17k midpoint seed put 129/132 Mathlib shards over a 400 GiB budget. Measured at 233 seeds: 8 over, depth-2 cascade, 242 measured shards at 161-397 GiB, zero failing constants, 17:20 wall. Small envs over-shard instead (init: ~20% extra STARK, first run only, reclaimed by the printed consolidation count). EXEC_RSS_PER_OWNED_BYTE returns to 2500 — the exec footprint is also env-dependent (~1000x ISLB, ~2300x Mathlib) and the gate's contract is never-OOM, so the slope carries the worst measured env (the 1100x refit OOM'd full-width Mathlib at 486/495 GB). Explorations implemented, measured, and removed en route (results are the keepable part): re-seed/calibration execution phases (re-execute the env to learn what the prove's own gated execution measures free); streaming cut-and-prove fusion (hint-row promotion is a full constrained replay under accumulation-based multiplicities); static byte->peak regressions (12-60% error, non-transferable); raw-sum group planning (bound held at 0.92-1.00x truth but fill equaled naive byte-sharding — summed fine segments count the shared core K times, and the claim spine is not the union of its parts'). Standing conclusion: planning signals must see row unions, only execution sees unions, so the prove run's gated execution is the planner and the seed only has to land in the right decade. --- Ix/Aiur/Protocol.lean | 37 ++++-- Ix/Aiur/Statistics.lean | 13 -- Ix/Cli/CheckCmd.lean | 218 ++++++++++++++++++-------------- Ix/Cli/ProveCmd.lean | 86 +++++++------ Ix/Cli/ShardCmd.lean | 47 ++++--- Ix/Common.lean | 11 +- Ix/KernelCheck.lean | 17 --- crates/aiur/src/synthesis.rs | 184 +++++++++++++++------------ crates/ffi/src/aiur/protocol.rs | 149 ++++++++++++---------- crates/ffi/src/kernel.rs | 64 ++++------ crates/kernel/src/shard.rs | 89 ++++++++----- 11 files changed, 500 insertions(+), 415 deletions(-) diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 19ae0791e..d90f9d224 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -230,6 +230,19 @@ opaque verify : @& AiurSystem → end AiurSystem +/-- Write a `.ixes` manifest for an EXPLICIT partition — the block lists + a run actually produced (splits included) rather than a planner's + output. `shardsBlob`: per shard, a 4-byte LE block count followed by + that many 32-byte block addresses; every env block must appear in + exactly one shard. `peaksBlob`: one 8-byte LE measured prover peak + per shard in order, recorded on the manifest for schedulers. Own + sizes, foreign blocks, cross-ingress and assumption roots are + recomputed from the env's static profile; prints the manifest + summary to stderr. -/ +@[extern "rs_shard_manifest_from_partition"] +opaque shardManifestFromPartition : @& EnvHandle → + @& ByteArray → @& ByteArray → @& String → IO Unit + namespace Bytecode.Toplevel /-- One shard's result from `shardCheckBatchWithEnv`. `weights` is the @@ -253,23 +266,19 @@ structure ShardResult where /-- Bytes per packed `weights` row: 32 address + 8 vspan + 8 mult. -/ def shardWeightRow : Nat := 48 -/-- Little-endian `UInt64` at `off`. -/ -private def readU64LE (ba : ByteArray) (off : Nat) : UInt64 := Id.run do - let mut v : UInt64 := 0 - for b in [0 : 8] do - v := v ||| ((ba.get! (off + b)).toUInt64 <<< (8 * b).toUInt64) - return v - /-- Fold `f` over the packed `(addrBytes, vspan, mult)` rows of `weights`. Trailing bytes that do not complete a row are ignored. -/ @[inline] def ShardResult.foldWeights {α : Type} (r : ShardResult) (init : α) - (f : α → ByteArray → UInt64 → UInt64 → α) : α := Id.run do - let mut acc := init - for i in [0 : r.weights.size / shardWeightRow] do - let off := i * shardWeightRow - acc := f acc (r.weights.extract off (off + 32)) - (readU64LE r.weights (off + 32)) (readU64LE r.weights (off + 40)) - return acc + (f : α → ByteArray → UInt64 → UInt64 → α) : α := + go (r.weights.size / shardWeightRow) 0 init +where + go : Nat → Nat → α → α + | 0, _, acc => acc + | rows + 1, off, acc => + go rows (off + shardWeightRow) <| f acc + (r.weights.extract off (off + 32)) + (r.weights.extract (off + 32) (off + 40)).toUInt64LE! + (r.weights.extract (off + 40) (off + 48)).toUInt64LE! @[extern "rs_aiur_toplevel_shard_check_batch"] private opaque shardCheckBatchWithEnv' : @& Bytecode.Toplevel → diff --git a/Ix/Aiur/Statistics.lean b/Ix/Aiur/Statistics.lean index 9ff9200c6..aa91de166 100644 --- a/Ix/Aiur/Statistics.lean +++ b/Ix/Aiur/Statistics.lean @@ -53,19 +53,6 @@ structure ExecutionStats where totalCacheHits : Nat deriving Inhabited -/-- Coarse PROVER RAM projection for a record with these circuit - heights: the committed trace bytes over the LDE domain, - `Σ nextPowerOfTwo(height) · committedWidth · 8 · 2^logBlowup`, with empty - circuits contributing nothing (the prover deactivates them). A - surrogate for relative shard sizing — how many shards must split - (over a prover budget) or could merge (far under it) — not an - exact allocator-level peak. -/ -def ExecutionStats.projectedProverBytes (stats : ExecutionStats) - (logBlowup : Nat := defaultCommitmentParameters.logBlowup) : Nat := - stats.circuits.foldl (init := 0) fun acc c => - if c.height == 0 then acc - else acc + Nat.nextPowerOfTwo c.height * c.width * 8 * (2 ^ logBlowup) - /-- Continuous transform-size surrogate: `0` at `0` (an empty circuit is deactivated by the prover), else `x·log2(max(x, 2))` — the clamp keeps a height-1 transform nonzero. -/ diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 4a2c867c5..ff4b5fc3b 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -116,8 +116,13 @@ def emitStats (compiled : Aiur.CompiledToplevel) line per constrained `check_const` query. The address is recovered by dereferencing the `Addr` argument — the LAST input slot, since `ci` is passed flattened by value — through `memory[32]`; `vspan` is the - constant's standalone check cost (memo hits replay the callee's - recorded span, so the numbers are order-independent shard weights). + constant's standalone check cost within its shard (memo hits replay + the callee's recorded span). Order-independent within a partition, + but NOT exact across partitions: a callee owned by a foreign shard + is assumed rather than replayed, so its span drops out of its + callers' rows (measured: ~10% of a 360-const fixture's rows shift + between a 1-shard and a 4-shard partition, a few by >2x). Schedule + off a profile measured under the partition being scheduled. Requires the execution to have run with `profile := true`, else every span reads 0. -/ def dumpProfile (compiled : Aiur.CompiledToplevel) @@ -505,20 +510,54 @@ private def blockAddrOf (addr : Address) (c : Ixon.Constant) : Address := | .dPrj prj => prj.block | _ => addr -/-- Owned constants of a shard: every env constant whose check-schedule block - is in `blocks`. +/-- Each block address mapped to the index of the list owning it. -/ +def blockIndexOf (lists : Array (Array Address)) : + Std.HashMap Address Nat := + (lists.mapIdx fun k l => (k, l)).foldl (init := {}) fun m (k, l) => + l.foldl (fun m blk => m.insert blk k) m - Constants whose bytes do not parse are skipped and therefore owned by - NOBODY. That is safe only because `shardsCover` fails the run when any - exist, so this is never reached with one present; without that gate a - silent skip here means a constant no shard ever checks. -/ -def ownedConstsForBlocks (ixonEnv : Ixon.Env) (blocks : Array Address) : Array Address := Id.run do - let blockSet : Std.HashSet Address := blocks.foldl (·.insert ·) {} - let mut o : Array Address := #[] - for (addr, lc) in ixonEnv.consts do - let some c := lc.get? | continue - if blockSet.contains (blockAddrOf addr c) then o := o.push addr - return o +/-- Owned constants per entry, in ONE env pass: `result[k]` is every env + constant whose check-schedule block is in `lists[k]`, in + env-iteration order (identical to a per-entry filter, so claim + digests are unchanged). Per-entry filtering rescans all consts each + call — at env scale (241 shards × 688k consts) that is ~30 min of + setup, vs seconds here. + + Constants whose bytes do not parse are owned by NOBODY. That is safe + only because `shardsCover` fails the run when any exist; without + that gate a silent skip here means a constant no shard ever + checks. -/ +def ownedConstsPer (ixonEnv : Ixon.Env) (lists : Array (Array Address)) : + Array (Array Address) := + let blockTo := blockIndexOf lists + ixonEnv.consts.fold (init := Array.replicate lists.size #[]) + fun owned addr lc => + match lc.get? with + | none => owned + | some c => + match blockTo.get? (blockAddrOf addr c) with + | some k => owned.modify k (·.push addr) + | none => owned + +/-- Owned constants of one shard: `ownedConstsPer` over a singleton. -/ +def ownedConstsForBlocks (ixonEnv : Ixon.Env) (blocks : Array Address) : + Array Address := + (ownedConstsPer ixonEnv #[blocks])[0]! + +/-- Partition a shard's already-known `owned` constants among `parts` + (block lists) by check-schedule block: one pass over the owned + consts, none over the env — the split-time companion of + `ownedConstsPer`, whose full env pass runs once per run. -/ +def partitionOwned (ixonEnv : Ixon.Env) (owned : Array Address) + (parts : Array (Array Address)) : Array (Array Address) := + let blockTo := blockIndexOf parts + owned.foldl (init := Array.replicate parts.size #[]) fun acc a => + match (ixonEnv.consts.get? a).bind (·.get?) with + | none => acc + | some c => + match blockTo.get? (blockAddrOf a c) with + | some k => acc.modify k (·.push a) + | none => acc /-- The `CheckEnv` claim digest a shard's proof commits to — reconstructed deterministically from the env + the shard's owned blocks. Matches the @@ -555,7 +594,7 @@ def runShardOwned (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) one env parse. -/ def runShardOwnedNative (envHandle : Aiur.EnvHandle) (compiled : Aiur.CompiledToplevel) (printStats : Bool) (statsOut : Option String) (profileOut : Option String) - (useBytecode : Bool) (shapes : Array Aiur.CircuitShape) + (useBytecode : Bool) (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) : IO UInt32 := do let owned := ownedConstsForBlocks ixonEnv blocks IO.println s!"[shard] shard {shardK}: {blocks.size} owned blocks → \ @@ -572,13 +611,6 @@ def runShardOwnedNative (envHandle : Aiur.EnvHandle) (compiled : Aiur.CompiledTo IO.eprintln s!"{label}: IxVM-native shard check error: {e}" return 1 | .ok r => - -- Prover RAM projection from this shard's executed heights: the - -- input to split/merge decisions against a prover budget. - let stats := Aiur.computeStats compiled r.queryCounts shapes - let bytes := stats.projectedProverBytes - let gib := Float.ofNat bytes / 1073741824.0 - IO.println s!"[shard {shardK}] projected prover RAM: \ - {gib} GiB (padded committed traces × blowup)" if printStats then emitStats compiled r.queryCounts statsOut if let some out := profileOut then dumpProfile compiled r.record out (ixonEnv.addrToName.get? ·) @@ -607,10 +639,8 @@ def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 | .ok h => pure h - let shapes := Aiur.circuitShapes compiled.bytecode - Aiur.defaultCommitmentParameters Aiur.defaultFriParameters runShardOwnedNative envHandle compiled printStats statsOut profileOut - useBytecode shapes ixonEnv blocks shardK + useBytecode ixonEnv blocks shardK /-- Coverage check over already-loaded env + shards: every constant's check-schedule block is owned by **exactly one** shard. That is the whole @@ -675,26 +705,31 @@ def cutBlocks (blocks : Array Address) (p : Nat) : Array (Array Address) := /-- Measured-peaks blob for the manifest emit: one 8-byte LE value per shard, in shard order. -/ -def peaksBlob (peaks : Array Nat) : ByteArray := Id.run do - let mut blob := ByteArray.empty - for pk in peaks do - let v := pk.toUInt64 - for b in [0 : 8] do - blob := blob.push (v >>> (8 * b.toUInt64)).toUInt8 - return blob +def peaksBlob (peaks : Array Nat) : ByteArray := + peaks.foldl (init := ByteArray.empty) fun blob pk => + blob ++ pk.toUInt64.toLEBytes /-- Wire encoding shared by the shard batch FFI and the manifest emit: per entry, a 4-byte LE count followed by the 32-byte addresses. -/ -def addrListsBlob (lists : Array (Array Address)) : ByteArray := Id.run do - let mut blob := ByteArray.empty - for l in lists do - let n := l.size.toUInt32 - blob := blob.push n.toUInt8 - blob := blob.push (n >>> 8).toUInt8 - blob := blob.push (n >>> 16).toUInt8 - blob := blob.push (n >>> 24).toUInt8 - for a in l do blob := blob ++ a.hash - return blob +def addrListsBlob (lists : Array (Array Address)) : ByteArray := + lists.foldl (init := ByteArray.empty) fun blob l => + l.foldl (fun b a => b ++ a.hash) (blob ++ l.size.toUInt32.toLEBytes) + +/-- Emit the partition a run actually validated as a `.ixes` manifest, + measured peaks included — the shared tail of `ix prove --out-ixes` + and `ix check --ram-budget --out-ixes`. Skipped with a note when any + shard failed: a corrected manifest describes a fully-validated + partition. -/ +def emitCorrectedManifest (tag : String) (envHandle : Aiur.EnvHandle) + (out : String) (partition : Array (Array Address × Nat)) + (failures : Nat) : IO Unit := do + if failures == 0 then + Aiur.shardManifestFromPartition envHandle + (addrListsBlob (partition.map (·.1))) + (peaksBlob (partition.map (·.2))) out + IO.println s!"[{tag}] corrected manifest → {out}" + else + IO.eprintln s!"--out-ixes {out} skipped: {failures} failure(s)" /-- Whole-partition check as ONE Rust rayon batch: work-stealing across shards, no chunk barriers (measured 2.3–2.5x faster than the @@ -710,8 +745,8 @@ def addrListsBlob (lists : Array (Array Address)) : ByteArray := Id.run do def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) (compiled : Aiur.CompiledToplevel) (useBytecode : Bool) (profileOut : Option String) - (json? : Option (String × String) := none) - (maxRamBytes : Nat := 0) (outIxes : Option String := none) : + (json? : Option (String × String)) + (maxRamBytes : Nat) (outIxes : Option String) : IO UInt32 := do -- The row's peak-rss needs the process-tree RSS sampler running -- (`peakTreeRssBytes` reports 0 otherwise); started before the env @@ -726,44 +761,31 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) | .ok h => pure h let funIdx := compiled.getFuncIdx `verify_claim |>.get! let jobs := jobs?.getD 0 - -- Assign every const to its shard in ONE env pass. Calling - -- `ownedConstsForBlocks` per shard rescans all consts each time — - -- at env scale (241 shards × 688k consts) that is ~30 min of setup. - -- Each shard's array keeps env-iteration order, identical to what - -- the per-shard filter produces, so claim digests are unchanged. - let ownedFor (waveBlocks : Array (Array Address)) : - Array (Array Address) := Id.run do - let mut blockToShard : Std.HashMap Address Nat := {} - for (blocks, k) in waveBlocks.mapIdx (fun k b => (b, k)) do - for blk in blocks do blockToShard := blockToShard.insert blk k - let mut owned : Array (Array Address) := - Array.replicate waveBlocks.size #[] - for (addr, lc) in ixonEnv.consts do - let some c := lc.get? | continue - match blockToShard.get? (blockAddrOf addr c) with - | some k => owned := owned.modify k (·.push addr) - | none => pure () - return owned -- `check_const`'s queries are what the weight rows are read from; a -- toplevel without it can still check, just not profile. let checkConstIdx := (compiled.getFuncIdx `check_const).getD 0 if profileOut.isSome && (compiled.getFuncIdx `check_const).isNone then IO.eprintln "--profile: no `check_const` in compiled toplevel" - let cutLabeled (label : String) (blocks : Array Address) (p : Nat) : - Array (String × Array Address) := - (cutBlocks blocks p).mapIdx fun i part => (s!"{label}.{i}", part) + let cutLabeled (label : String) (blocks owned : Array Address) + (p : Nat) : Array (String × Array Address × Array Address) := + let parts := cutBlocks blocks p + (parts.zip (partitionOwned ixonEnv owned parts)).mapIdx + fun i (part, po) => (s!"{label}.{i}", part, po) -- One loop over execution waves. Wave 0 is the planned partition; - -- with `--max-ram` every over-budget shard is cut into the peak + -- with `--ram-budget` every over-budget shard is cut into the peak -- model's suggested part count and the parts re-batched as the next -- wave, until everything fits or is a single block. Without a -- budget the FFI answers 1 part everywhere and the loop is a single -- wave — the plain batch check. Waves after the first never - -- profile: vspans are partition-invariant, so wave 0 already - -- carries every constant's row. - let mut wave : Array (String × Array Address) := - shards.mapIdx fun k b => (s!"{k}", b) + -- profile: wave 0 already carries one row per constant, measured + -- under the planned partition — the one schedulers consume. + -- The whole run's ownership assignment: one env pass here, and + -- every later wave's parts inherit their parent's owned consts via + -- `partitionOwned` — no wave ever rescans the env. + let mut wave : Array (String × Array Address × Array Address) := + (shards.zip (ownedConstsPer ixonEnv shards)).mapIdx + fun k (b, o) => (s!"{k}", b, o) let mut waveNum := 0 - let mut failures : Nat := 0 let mut failed : Array String := #[] let mut final : Array (Array Address × Nat) := #[] let mut totalConsts := 0 @@ -775,13 +797,12 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) else IO.println s!"[wave {waveNum}] re-executing {wave.size} part(s)" (← IO.getStdout).flush - let ownedPer := ownedFor (wave.map (·.2)) - let profile := profileOut.isSome && waveNum == 0 + let ownedPer := wave.map (·.2.2) let start ← IO.monoMsNow match compiled.bytecode.shardCheckBatchWithEnv funIdx envHandle (addrListsBlob ownedPer) useBytecode jobs Aiur.defaultCommitmentParameters Aiur.defaultFriParameters - profile checkConstIdx maxRamBytes with + (profileOut.isSome && waveNum == 0) checkConstIdx maxRamBytes with | .error e => IO.eprintln s!"shard batch (wave {waveNum}): {e}"; return 1 | .ok rs => if waveNum == 0 then @@ -790,14 +811,11 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) -- extras outside the benchmarked engine window. elapsedMs := (← IO.monoMsNow) - start totalConsts := ownedPer.foldl (· + ·.size) 0 - let mut next : Array (String × Array Address) := #[] - for j in [:rs.size] do - let r := rs[j]! - let (label, blocks) := wave[j]! - let gib := Float.ofNat r.peakBytes / 1073741824.0 + let mut next : Array (String × Array Address × Array Address) := #[] + for (r, label, blocks, owned) in rs.zip wave do + let gib := toGib r.peakBytes if !r.error.isEmpty then IO.eprintln s!"[shard {label}] FAILED: {r.error}" - failures := failures + 1 failed := failed.push s!"shard {label}: {r.error}" final := final.push (blocks, r.peakBytes) else if r.suggestedParts <= 1 then @@ -806,17 +824,16 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) else if blocks.size <= 1 then IO.eprintln s!"[shard {label}] peak {gib} GiB over budget and a \ single block — cannot split" - failures := failures + 1 failed := failed.push s!"shard {label}: single block over budget" final := final.push (blocks, r.peakBytes) else IO.println s!"[shard {label}] peak {gib} GiB over budget — cut \ into {r.suggestedParts}" - next := next ++ cutLabeled label blocks r.suggestedParts + next := next ++ cutLabeled label blocks owned r.suggestedParts -- Weight rows are appended once, from wave 0: Rust already -- reduced each shard's record under its own task, so nothing -- here holds a record alive. - if profile then + if waveNum == 0 then if let some out := profileOut then let h ← IO.FS.Handle.mk out .append for r in rs do @@ -829,16 +846,21 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) waveNum := waveNum + 1 if maxRamBytes > 0 then IO.println s!"[split-audit] {final.size} part(s) from {shards.size} \ - planned shard(s), {waveNum - 1} split wave(s), {failures} failure(s)" + planned shard(s), {waveNum - 1} split wave(s), {failed.size} failure(s)" + -- Consolidation is arithmetic, never an execution: the measured + -- sum only shrinks as shards get coarser, so this count is a safe + -- under-count — and the next run's mandatory executions verify it + -- inline. 95%: margin for the model's +1.7% under-projection. + let sum := final.foldl (· + ·.2) 0 + let target := maxRamBytes * 95 / 100 + let n1 := max 1 ((sum + target - 1) / target) + if failed.isEmpty && n1 < final.size then + IO.println s!"[split-audit] measured total {toGib sum} GiB — \ + {n1} shard(s) would fit the budget: re-shard with --shards {n1}" -- The recalibrated partition — what this run actually validated — -- written as the manifest the next run should start from. if let some out := outIxes then - if failures == 0 then - Ix.KernelCheck.rsShardManifestFromPartitionFFI ixePath - (addrListsBlob (final.map (·.1))) (peaksBlob (final.map (·.2))) out - IO.println s!"[split-audit] recalibrated manifest → {out}" - else - IO.eprintln s!"--out-ixes {out} skipped: {failures} failure(s)" + emitCorrectedManifest "split-audit" envHandle out final failed.size -- One env-keyed results row for `ix bench run --backend aiur-sharded-env`: -- the measured window is the wave-0 batch FFI call (env load and -- blob setup are excluded, matching what the benchmark tracks — the @@ -848,17 +870,17 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) let tput := if elapsedMs > 0 then totalConsts.toFloat * 1000.0 / elapsedMs.toFloat else 0.0 let peakRss ← TracingTexray.peakTreeRssBytes - let status := if failures == 0 then "ok" else "rejected" + let status := if failed.isEmpty then "ok" else "rejected" Ix.Benchmark.Results.writeRow path key status [ ("constants", Lean.toJson totalConsts) , ("shards", Lean.toJson final.size) , ("check-time", Ix.Benchmark.Results.jsonRound 3 secs) , ("throughput", Ix.Benchmark.Results.jsonRound 2 tput) , ("peak-rss", Lean.toJson peakRss) ] - if failures == 0 then + if failed.isEmpty then IO.println s!"All {final.size} shard(s) passed" return 0 - IO.eprintln s!"{failures} of {final.size} shard(s) FAILED:" + IO.eprintln s!"{failed.size} of {final.size} shard(s) FAILED:" for f in failed do IO.eprintln s!" {f}" -- Under `--json` a kernel rejection is the benchmark's `rejected` -- exit (the row is already written), same contract as `check-rs`. @@ -988,7 +1010,7 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do (f.as! String, ((p.flag? "json-name").map (·.as! String)).getD "env") return (← runShardBatchNative manifest ixe ((p.flag? "jobs").map (·.as! Nat)) compiled useBytecode profileOut json? - (((p.flag? "max-ram").map (·.as! Nat)).getD 0 * 1073741824) + (((p.flag? "ram-budget").map (·.as! Nat)).getD 0 * gibBytes) ((p.flag? "out-ixes").map (·.as! String))) | _, _, _ => -- `--jobs N` (N ≠ 1) with an `--ixe` env and no `--claim` takes the @@ -1019,14 +1041,14 @@ def checkCmd : Cli.Cmd := `[Cli| "ixe" : String; "Path to a serialized `.ixe` env. When set, the binary reads the env from disk instead of using the compiled-in Lean env." "claim" : String; "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, runs the `verify_claim` entrypoint once over the claim's witness against the `--ixe` env (single execution, skips per-const iteration)." "stats-out" : String; "Redirect the per-circuit statistics dump to this file (only used when exactly one constant is targeted)." - "profile" : String; "Append per-constant virtual-gas costs to this file: one ` [name]` line per `check_const` query, read from the execution's QueryRecordHandle (names joined on the shard paths, where the env's addr→name index is loaded). The vspan is the constant's standalone check cost — memo hits replay the callee's recorded span — so the numbers are order-independent shard weights. Not available with `--interp source`." + "profile" : String; "Append per-constant virtual-gas costs to this file: one ` [name]` line per `check_const` query, read from the execution's QueryRecordHandle (names joined on the shard paths, where the env's addr→name index is loaded). The vspan is the constant's standalone check cost within its shard — memo hits replay the callee's recorded span. Order-independent within a partition, but spans of constants whose dependency cone crosses an assumption boundary shift between partitions (foreign callees are assumed, not replayed); schedule off a profile measured under the partition being scheduled. Not available with `--interp source`." "ixes" : String; "Path to a `.ixes` shard manifest (with --ixe). With --shard K: check the constants owned by shard K (ingress their closure, skip the frontier). Without --shard: check every shard of the partition concurrently, after a coverage check." "shard" : Nat; "0-based shard index K (with --ixe + --ixes): check the constants owned by shard K of the manifest's partition." "jobs" : Nat; "Parallelism. With --ixes (no --shard): max shards checked concurrently (default: all at once). With --ixe alone and N ≠ 1: check the targeted constants on N Rust threads (0 = all cores), each claim over its own private record — peak RAM is bounded by N in-flight claim closures." "json" : String; "With --ixes (no --shard): append one env-keyed results row (see Ix.Benchmark.Results) for the batch to this file — check-time, throughput, peak-rss, constants, shards. Used by `ix bench run --backend aiur-sharded-env`." "json-name" : String; "Row key for the --json row (default: `env`)." - "max-ram" : Nat; "Per-shard prover-RAM budget, GiB (with --ixes, no --shard): after the batch, cut every shard whose projected prover peak exceeds the budget into the peak model's suggested part count and re-batch the parts, wave by wave, until everything fits. Executions only — the cheap audit of a partition's split behavior; the wave count is the recursion depth. Omit for a plain check." - "out-ixes" : String; "With --max-ram: write the recalibrated partition — the block lists the wave loop actually validated, splits included — as a `.ixes` manifest to this path. Skipped if any shard failed. The manifest the next run of this env should start from." + "ram-budget" : Nat; "The destination prove box's per-shard RAM budget, GiB (with --ixes, no --shard): after the batch, cut every shard whose projected prover peak exceeds the budget into the peak model's suggested part count and re-batch the parts, wave by wave, until everything fits — the exec-only split audit. Under-filled partitions get a printed suggestion (the shard count the measured total says would fit), never an extra execution: re-shard with --shards N and let the next run's mandatory executions verify it inline. Same unit and model as `ix prove --max-ram`, but no auto-detection: the budget describes the prove box the partition is destined for, not the machine running the check. Omit for a plain check." + "out-ixes" : String; "With --ram-budget: write the recalibrated partition — the block lists the wave loop actually validated, splits included — as a `.ixes` manifest to this path. Skipped if any shard failed. The manifest the next run of this env should start from." ARGS: ...names : String; "Fully-qualified Lean.Name(s) to check. With none, iterate every named constant in the env (sorted)." diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index 2daa0f7d9..e6bb930bc 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -139,9 +139,8 @@ partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) (ixonEnv : Ixon.Env) (aiurSystem : Aiur.AiurSystem) (funIdx : Aiur.Bytecode.FunIdx) (maxRamBytes : Nat) (execOnly : Bool) (label : String) - (blocks : Array Address) : + (blocks owned : Array Address) : IO (Except String (Array (Array Address × Nat))) := do - let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks ixonEnv blocks let mut blob := ByteArray.empty for a in owned do blob := blob ++ a.hash @@ -151,12 +150,12 @@ partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) execOnly with | .error e => return .error s!"{label}: shardProveWithEnv error: {e}" | .ok { claimBytes, proof, peakBytes, suggestedParts } => - let gib := Float.ofNat peakBytes / 1073741824.0 + let gib := toGib peakBytes match proof with | none => - -- Exec-only leaf: the peak fit (parts = 1), there is just no - -- STARK behind it. The partition bookkeeping is identical. - if execOnly && suggestedParts <= 1 then + -- The peak fit but nothing proved: reachable only in exec-only + -- mode (a budgeted prove either proves or suggests ≥ 2 parts). + if suggestedParts <= 1 then IO.println s!"[{label}] prover peak {gib} GiB (exec-only)" return .ok #[(blocks, peakBytes)] -- A single block is the atom the kernel checks together; there is @@ -167,10 +166,12 @@ partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) let cut := Ix.Cli.CheckCmd.cutBlocks blocks suggestedParts IO.println s!"[{label}] peak {gib} GiB over budget — cutting \ {blocks.size} blocks into {cut.size} parts" + let cutOwned := Ix.Cli.CheckCmd.partitionOwned ixonEnv owned cut let mut proven : Array (Array Address × Nat) := #[] - for i in [0 : cut.size] do + for (i, part, po) in (cut.zip cutOwned).mapIdx + (fun i (part, po) => (i, part, po)) do match ← proveBlocksWithinBudget envHandle ixonEnv aiurSystem funIdx - maxRamBytes execOnly s!"{label}.{i}" cut[i]! with + maxRamBytes execOnly s!"{label}.{i}" part po with | .error e => return .error e | .ok parts => proven := proven ++ parts return .ok proven @@ -191,16 +192,16 @@ partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) /-- Prove shard `shardK` of the partition, splitting it as needed. Returns the block sets actually proven for that shard. -/ def runShardProveNative (envHandle : Aiur.EnvHandle) (ixonEnv : Ixon.Env) - (shards : Array (Array Address)) (shardK : Nat) + (shards ownedPerShard : Array (Array Address)) (shardK : Nat) (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) (maxRamBytes : Nat) (execOnly : Bool) : IO (Except String (Array (Array Address × Nat))) := do - match shards[shardK]? with - | none => return .error s!"shard {shardK} out of range (0..{shards.size})" - | some blocks => + match shards[shardK]?, ownedPerShard[shardK]? with + | some blocks, some owned => let funIdx := compiled.getFuncIdx `verify_claim |>.get! proveBlocksWithinBudget envHandle ixonEnv aiurSystem funIdx maxRamBytes - execOnly s!"shard {shardK}" blocks + execOnly s!"shard {shardK}" blocks owned + | _, _ => return .error s!"shard {shardK} out of range (0..{shards.size})" /-- Report the partition a prove run actually produced against the one its manifest planned. They differ exactly when a shard was split. -/ @@ -222,18 +223,18 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do -- partition was sized against, re-checked here against each shard's -- measured peak. 0 = detect (85% of `MemAvailable`, the check batch's -- gate policy — see `shardProveWithEnv`). - let maxRamBytes := ((p.flag? "max-ram").map (·.as! Nat)).getD 0 * 1073741824 + let maxRamBytes := + ((p.flag? "max-ram").map (·.as! Nat)).getD 0 * gibBytes let execOnly := p.hasFlag "exec-only" let outIxes := (p.flag? "out-ixes").map (·.as! String) -- Both `--ixes` branches end the same way: the partition the run -- actually proved, written as the manifest to start the next run from. - let emitCorrected (ixe : String) (partition : Array (Array Address × Nat)) : + let emitCorrected (envHandle : Aiur.EnvHandle) + (partition : Array (Array Address × Nat)) (failures : Nat) : IO Unit := do if let some out := outIxes then - Ix.KernelCheck.rsShardManifestFromPartitionFFI ixe - (Ix.Cli.CheckCmd.addrListsBlob (partition.map (·.1))) - (Ix.Cli.CheckCmd.peaksBlob (partition.map (·.2))) out - IO.println s!"[prove] corrected manifest → {out}" + Ix.Cli.CheckCmd.emitCorrectedManifest "prove" envHandle out partition + failures let ixePath : Option String := (p.flag? "ixe").map (·.as! String) let claimHex : Option String := (p.flag? "claim").map (·.as! String) let names := (p.variableArgsAs! String).toList @@ -255,7 +256,8 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let envHandle ← match Aiur.EnvHandle.fromIxe ixe with | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 | .ok h => pure h - match ← runShardProveNative envHandle ixonEnv shards k aiurSystem + match ← runShardProveNative envHandle ixonEnv shards + (Ix.Cli.CheckCmd.ownedConstsPer ixonEnv shards) k aiurSystem compiled maxRamBytes execOnly with | .error e => IO.eprintln e; return 1 | .ok parts => @@ -263,10 +265,11 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do -- partition. reportPartition parts 1 -- The corrected whole partition: the plan with shard k replaced - -- by the parts this run actually proved. - emitCorrected ixe + -- by the parts this run actually proved (other shards stay + -- unmeasured — this run never executed them). + emitCorrected envHandle ((shards.extract 0 k).map (·, 0) ++ parts - ++ (shards.extract (k + 1) shards.size).map (·, 0)) + ++ (shards.extract (k + 1) shards.size).map (·, 0)) 0 return 0 | some ixe, some manifest, none => -- IxVM-native all-shards prove. Same envHandle reused across @@ -279,24 +282,35 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do | .ok h => pure h -- Accumulate the partition the run actually produced. Splits stay -- in this process, so the manifest describing them is written - -- once at the end rather than rewritten per split. + -- once at the end rather than rewritten per split. Ownership is + -- assigned in ONE env pass here; splits inherit it. + let ownedPer := Ix.Cli.CheckCmd.ownedConstsPer ixonEnv shards let mut proven : Array (Array Address × Nat) := #[] - let mut failed : Array (Nat × String) := #[] + let mut failed : Array String := #[] for k in [0 : shards.size] do - match ← runShardProveNative envHandle ixonEnv shards k aiurSystem - compiled maxRamBytes execOnly with - | .error e => IO.eprintln e; failed := failed.push (k, e) + match ← runShardProveNative envHandle ixonEnv shards ownedPer k + aiurSystem compiled maxRamBytes execOnly with + | .error e => IO.eprintln e; failed := failed.push e | .ok parts => proven := proven ++ parts if failed.isEmpty then reportPartition proven shards.size - emitCorrected ixe proven - return 0 - IO.eprintln s!"[prove] {failed.size} of {shards.size} shard(s) FAILED:" - for (k, e) in failed do - IO.eprintln s!" shard {k}: {e}" - if let some out := outIxes then - IO.eprintln s!"--out-ixes {out} skipped: {failed.size} failure(s)" - return 1 + -- Consolidation is arithmetic from the peaks this run already + -- measured, never an extra execution: the measured sum only + -- shrinks as shards get coarser, so the count is a safe + -- under-count, verified inline by the next run's own gate. + if maxRamBytes > 0 then + let sum := proven.foldl (· + ·.2) 0 + let n1 := max 1 ((sum + maxRamBytes * 95 / 100 - 1) + / (maxRamBytes * 95 / 100)) + if n1 < proven.size then + IO.println s!"[prove] measured total {toGib sum} GiB — {n1} \ + shard(s) would fit the budget: re-shard with --shards {n1}" + else + IO.eprintln s!"[prove] {failed.size} of {shards.size} shard(s) FAILED:" + for e in failed do + IO.eprintln s!" {e}" + emitCorrected envHandle proven failed.size + return if failed.isEmpty then 0 else 1 | _, _, _ => Ix.Cli.CheckCmd.forEachClaim ixePath claimHex names keepGoing "prove" false runOne diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean index e2f0e6d29..148b8b6a7 100644 --- a/Ix/Cli/ShardCmd.lean +++ b/Ix/Cli/ShardCmd.lean @@ -31,7 +31,9 @@ -/ module public import Cli +public import Ix.Common public import Ix.KernelCheck +public import Ix.Cli.CheckLeanCmd public import Ix.Cli.ConstsFile public section @@ -143,13 +145,11 @@ def runShardCmd (p : Cli.Parsed) : IO UInt32 := do | none => -- STATIC strategy (no out-of-circuit profiling): byte-balanced min-cut -- over the env's walk-edge nets + predicted-FFT rebalance post-pass. - -- Shard count comes from `--shards N`, or NAIVELY from `--max-ram G`: - -- without a profile the planner cannot know a shard's real prover - -- peak, so it estimates it from serialized env bytes via a measured - -- amplification factor and picks N so the estimated per-shard peak - -- fits the budget. The projections printed by an executed run - -- (`ix check --ixes --batch`) are the ground truth that corrects - -- the estimate — over-budget shards re-split, far-under merge. + -- Shard count comes from `--shards N`, or from the SEED heuristic + -- under `--max-ram G` — a bracketed order-of-magnitude count, never + -- a sizer: boundaries and budget fitting are measured where + -- execution happens anyway (the prove gate splits over-budget + -- shards inline and the corrected manifest remembers the leaves). if maxCycles.isSome then p.printError "error: --max-cycles requires --profile (its budget \ model is calibrated on profiled op counters)" @@ -159,17 +159,28 @@ def runShardCmd (p : Cli.Parsed) : IO UInt32 := do | none, some gib => if gib == 0 then p.printError "error: --max-ram must be positive"; return 1 + -- SEED heuristic, not a sizer, calibrated to MATHLIB-CLASS + -- amplification because that is the common shape of real Lean + -- libraries (Mathlib and everything importing it), not an + -- outlier. Measured peak-per-env-byte at fitting granularity: + -- Mathlib ~20,200x at 132 shards and rising with count (a + -- 17,000x midpoint seed put 129/132 shards over a 400 GiB + -- budget, costing a full extra execution wave, 2026-08-29); + -- FLT ~19,600x at 241; init only ~12,500-14,000x. Targeting + -- 2/3 of the budget with the 20,000x class constant lands + -- Mathlib-class envs at ~70% fill with single-digit splits + -- (measured: FLT 241 shards, 6 over; Mathlib 233, mean 285). + -- Low-amplification small envs over-shard instead (init: ~50% + -- first-run fill) — the cheap direction, reclaimed by the + -- printed consolidation count; gated execution corrects every + -- boundary either way. + let seedAmp := 20000 let envBytes := (← System.FilePath.metadata envPath).byteSize.toNat - -- Prover-peak-per-env-byte, measured on init and FLT partitions - -- (2026-08-21): analytic prover peaks landed at ~20,000-21,000x - -- the shard's serialized bytes. Target ~2/3 of the budget so - -- the median sits under it with headroom for the measured - -- ~2.5x median-to-max spread across shards of one partition. - let amplification := 20000 - let targetBytes := gib * 1024 * 1024 * 1024 * 2 / 3 - let n := max 1 ((envBytes * amplification + targetBytes - 1) / targetBytes) - IO.println s!"[shard] naive RAM sizing: {envBytes} env bytes × \ - {amplification} / ({gib} GiB × 2/3) → {n} shard(s)" + let targetBytes := gib * gibBytes * 2 / 3 + let n := max 1 ((envBytes * seedAmp + targetBytes - 1) / targetBytes) + IO.println s!"[shard] seed count: {envBytes} env bytes × \ + {seedAmp} / ({gib} GiB × 2/3) → {n} shard(s) (heuristic; gated \ + execution corrects every boundary)" pure n | none, none => p.printError "error: the static strategy (no --profile) requires \ @@ -208,7 +219,7 @@ def shardCmd : Cli.Cmd := `[Cli| profile : String; "Path to a `.ixprof` from `ix profile`. When given, use the profiled strategy (cap budgeting / balanced min-cut over measured costs); when absent, the static strategy partitions the `.ixe` directly." shards : Nat; "Fixed number of shards N (static strategy; overrides --max-ram sizing and the profiled default budget sizing)" "max-cycles" : Nat; "Per-shard guest-cycle budget (profiled strategy only)" - "max-ram" : Nat; "Per-shard prover-RAM budget, GiB. Static strategy: NAIVE sizing — estimates per-shard prover peak from serialized env bytes (measured ~20,000x amplification) and picks the shard count so the estimate fits ~2/3 of the budget; executed projections then correct it (split/merge). Profiled strategy: budget from measured op counters (default: detected system RAM)." + "max-ram" : Nat; "Per-shard prover-RAM budget, GiB. Static strategy: SEED heuristic for the shard count — Mathlib-class amplification (~20,000× env bytes, the common shape of real Lean libraries) against 2/3 of the budget, landing that class at ~70% fill with single-digit splits; small low-amplification envs over-shard instead (the cheap, reclaimable direction). The prove gate corrects every boundary by execution. Profiled strategy: budget from measured op counters (default: detected system RAM)." balance : Nat; "Per-bisection balance tolerance, percent (default 5)" parallelism : Nat; "Provers assumed for the prove-time estimate (profiled strategy only; default 1 = sequential)" out : String; "Output .ixes manifest path (default: env base name + `.ixes`, e.g. init.ixe → init.ixes)" diff --git a/Ix/Common.lean b/Ix/Common.lean index 52a2308f9..add05a783 100644 --- a/Ix/Common.lean +++ b/Ix/Common.lean @@ -439,17 +439,24 @@ def Nat.formatMs (ms : Nat) : String := else "< 1ms" +/-- Bytes per GiB — the unit of the RAM-budget flags and every + prover-peak log line. -/ +def gibBytes : Nat := 1024 * 1024 * 1024 + +/-- Bytes rendered as GiB for log lines. -/ +def toGib (bytes : Nat) : Float := bytes.toFloat / gibBytes.toFloat + /-- Format a byte count with appropriate unit suffix (B, kB, MB, GB). -/ def fmtBytes (n : Nat) : String := if n < 1024 then s!"{n} B" else if n < 1024 * 1024 then let kb := n * 10 / 1024 s!"{kb / 10}.{kb % 10} kB" - else if n < 1024 * 1024 * 1024 then + else if n < gibBytes then let mb := n * 10 / (1024 * 1024) s!"{mb / 10}.{mb % 10} MB" else - let gb := n * 10 / (1024 * 1024 * 1024) + let gb := n * 10 / gibBytes s!"{gb / 10}.{gb % 10} GB" /-- ` · rss X.Y GiB (hwm Z.W)` from `/proc/self/status`; empty where diff --git a/Ix/KernelCheck.lean b/Ix/KernelCheck.lean index bd3451f53..d403997a5 100644 --- a/Ix/KernelCheck.lean +++ b/Ix/KernelCheck.lean @@ -207,23 +207,6 @@ opaque rsShardEnvStaticFFI : @& String → -- .ixes output path ("" = skip) IO Unit -/-- FFI: write a `.ixes` manifest for an EXPLICIT partition — the block - lists a run actually produced (splits included) rather than a - planner's output. `shardsBlob`: per shard, a 4-byte LE block count - followed by that many 32-byte block addresses; every env block must - appear in exactly one shard. Own sizes, foreign blocks, - cross-ingress and assumption roots are recomputed from the env's - static profile; each shard's `measured_peak_bytes` comes from - `peaksBlob` (empty, or one 8-byte LE peak per shard in order). - Prints the manifest summary to stderr. -/ -@[extern "rs_shard_manifest_from_partition"] -opaque rsShardManifestFromPartitionFFI : - @& String → -- .ixe path - @& ByteArray → -- partition blob - @& ByteArray → -- measured-peaks blob - @& String → -- .ixes output path - IO Unit - /-- FFI: dump the static block-level reference graph of a `.ixe` as text: `block ` per ingress unit and `edge ` per deduped claim-walk edge at block diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 8e86f8741..92aae29f8 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -38,6 +38,22 @@ pub struct PeakProveBytes { pub peak: usize, } +/// Outcome of a budget-gated prove +/// ([`AiurSystem::prove_ixvm_within_budget`]). Only the case that ran a +/// STARK carries a proof; the other two report the measured peak the +/// caller decides with. +// One short-lived value per prove; the variant size gap is irrelevant. +#[allow(clippy::large_enum_variant)] +pub enum GatedProve { + /// Fit the budget; proven from the gating record. + Proved { claim: Vec, proof: AiurProof, peak: usize }, + /// Over budget: the record was dropped, and `parts` is the count + /// [`AiurSystem::suggested_split_parts`] projects will fit. + Split { peak: usize, parts: usize }, + /// `exec_only` with a fitting peak: measured, nothing left to do. + Measured { peak: usize }, +} + pub struct AiurSystem { toplevel: Toplevel, // perhaps remove the key from the system in verifier only mode? @@ -73,6 +89,27 @@ pub struct CircuitShape { pub preprocessed_height: usize, } +/// Raw row count of a circuit under `record`, ceil-divided into `parts` +/// even shares — `parts = 1` is the record's exact heights. The byte +/// gadgets keep their fixed heights: they are the same size in every +/// shard and are most of the peak model's floor, which dividing cannot +/// shrink. +fn raw_of( + record: &QueryRecord, + parts: usize, +) -> impl Fn(usize, &CircuitType) -> usize + '_ { + move |_, ct| match ct { + CircuitType::Function { idx } => { + record.function_queries[*idx].len().div_ceil(parts) + }, + CircuitType::Memory { width } => { + record.memory_queries.get(width).map_or(0, |m| m.len().div_ceil(parts)) + }, + CircuitType::Bytes1 => 256, + CircuitType::Bytes2 => 65536, + } +} + impl AiurSystem { pub fn build( toplevel: Toplevel, @@ -230,14 +267,7 @@ impl AiurSystem { /// which per-fft models blur. pub fn peak_prove_bytes(&self, record: &QueryRecord) -> PeakProveBytes { self.peak_prove_bytes_by( - |_, ct| match ct { - CircuitType::Function { idx } => record.function_queries[*idx].len(), - CircuitType::Memory { width } => { - record.memory_queries.get(width).map_or(0, |m| m.len()) - }, - CircuitType::Bytes1 => 256, - CircuitType::Bytes2 => 65536, - }, + raw_of(record, 1), crate::execute::record_retained_bytes(record), ) } @@ -302,6 +332,48 @@ impl AiurSystem { } } + /// Per-circuit raw heights of `record` in system order, with the + /// record's retained bytes as the trailing element — the composable + /// measurement the shard-planning group bound sums: per-circuit + /// unions are bounded by elementwise sums, so summed vectors feed + /// [`Self::peak_of_raws`] as a sound upper bound on a merged shard. + pub fn raw_heights(&self, record: &QueryRecord) -> Vec { + let f = raw_of(record, 1); + let mut v: Vec = self + .circuit_types() + .iter() + .enumerate() + .map(|(i, ct)| f(i, ct) as u64) + .collect(); + v.push(crate::execute::record_retained_bytes(record) as u64); + v + } + + /// Evaluate the peak model on a raw-height vector from + /// [`Self::raw_heights`] — possibly an elementwise SUM of several + /// segments' vectors, in which case the result is an upper bound on + /// the merged shard's peak. Gadget circuits are re-fixed to their + /// constant heights internally, so dumb elementwise summation stays + /// valid. `None` on a length mismatch. + pub fn peak_of_raws(&self, raws: &[u64]) -> Option { + let ncirc = self.system.circuits.len(); + if raws.len() != ncirc + 1 { + return None; + } + let record_bytes = raws[ncirc] as usize; + let peak = self + .peak_prove_bytes_by( + |i, ct| match ct { + CircuitType::Bytes1 => 256, + CircuitType::Bytes2 => 65536, + _ => raws[i] as usize, + }, + record_bytes, + ) + .peak; + Some(peak) + } + /// Smallest power-of-two part count whose projected per-part peak /// fits `max_bytes`, assuming the record's rows divide evenly across /// parts. The gadget circuits keep their constant heights — they are @@ -327,20 +399,7 @@ impl AiurSystem { // count; stop rather than search forever. while parts < (1 << 20) { let peak = self - .peak_prove_bytes_by( - |_, ct| match ct { - CircuitType::Function { idx } => { - record.function_queries[*idx].len().div_ceil(parts) - }, - CircuitType::Memory { width } => record - .memory_queries - .get(width) - .map_or(0, |m| m.len().div_ceil(parts)), - CircuitType::Bytes1 => 256, - CircuitType::Bytes2 => 65536, - }, - record_bytes / parts, - ) + .peak_prove_bytes_by(raw_of(record, parts), record_bytes / parts) .peak; if peak <= max_bytes { break; @@ -465,30 +524,29 @@ impl AiurSystem { &mut IOBuffer, ) -> Result<(QueryRecord, Vec), ExecError>, { - self - .prove_ixvm_within_budget(fun_idx, input, io_buffer, executor, None) - .map_or_else( - |_| unreachable!("an unbudgeted prove never rejects"), - |(claim, proof, _peak)| (claim, proof), - ) + match self + .prove_ixvm_within_budget(fun_idx, input, io_buffer, executor, None, false) + { + GatedProve::Proved { claim, proof, .. } => (claim, proof), + _ => unreachable!("an unbudgeted prove always proves"), + } } /// `prove_ixvm`, but the record's projected prover peak has to fit - /// `max_bytes` before any proving starts. `None` skips the check. + /// `max_bytes` before any proving starts (`None` skips the check), + /// and `exec_only` stops after execution + measurement — the split + /// loop runs on executions alone, no STARK started. /// /// The peak is measured on the REAL record ([`Self::peak_prove_bytes`]), /// not estimated from serialized bytes, so an over-budget shard is /// caught in the gap between execution and the witness phase — before - /// the LDE/commit/FRI phases that would actually exhaust the box. The - /// record is dropped rather than proven and `Err((peak, parts))` - /// comes back: the measured peak, and the part count - /// [`Self::suggested_split_parts`] projects will fit — computed here + /// the LDE/commit/FRI phases that would actually exhaust the box: the + /// record is dropped and [`GatedProve::Split`] carries the part count + /// [`Self::suggested_split_parts`] projects will fit, computed here /// because this is the last moment the record exists to read counts - /// from. - /// - /// On success the peak is returned too: proving a shard measures it for - /// free, so a prove run yields the same split/merge signal a check run - /// does without a second execution. + /// from. Every outcome carries the measured peak: proving a shard + /// measures it for free, so a prove run yields the same split/merge + /// signal a check run does without a second execution. #[tracing::instrument( level = "info", skip_all, @@ -501,7 +559,8 @@ impl AiurSystem { io_buffer: &mut IOBuffer, executor: F, max_bytes: Option, - ) -> Result<(Vec, AiurProof, usize), (usize, usize)> + exec_only: bool, + ) -> GatedProve where F: FnOnce( &Toplevel, @@ -521,50 +580,15 @@ impl AiurSystem { if let Some(max) = max_bytes && peak > max { - return Err((peak, self.suggested_split_parts(&query_record, max))); + let parts = self.suggested_split_parts(&query_record, max); + return GatedProve::Split { peak, parts }; + } + if exec_only { + return GatedProve::Measured { peak }; } let (claim, proof) = self.prove_from_execution(fun_idx, input, io_buffer, query_record, &output); - Ok((claim, proof, peak)) - } - - /// Execute-only twin of [`Self::prove_ixvm_within_budget`]: run the - /// execution, measure the record's projected peak, and go no further. - /// - /// Returns `(peak, parts)`: `parts` is 1 when the peak fits - /// `max_bytes` (or no budget is given), else the split count - /// [`Self::suggested_split_parts`] projects will fit. This is the dry - /// leg of the split loop — sizing or auditing a partition costs - /// executions only, never a STARK. - pub fn execute_peak_ixvm( - &self, - fun_idx: FunIdx, - input: &[G], - io_buffer: &mut IOBuffer, - executor: F, - max_bytes: Option, - ) -> (usize, usize) - where - F: FnOnce( - &Toplevel, - FunIdx, - Vec, - &mut IOBuffer, - ) -> Result<(QueryRecord, Vec), ExecError>, - { - let _g = tracing::info_span!("aiur/execute_ixvm").entered(); - let (query_record, _output) = - executor(&self.toplevel, fun_idx, input.to_vec(), io_buffer) - .expect("IxVM-native Aiur execution failed during execute_peak"); - drop(_g); - let peak = self.peak_prove_bytes(&query_record).peak; - let parts = match max_bytes { - Some(max) if peak > max => { - self.suggested_split_parts(&query_record, max) - }, - _ => 1, - }; - (peak, parts) + GatedProve::Proved { claim, proof, peak } } #[inline] diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 76ea845e9..d7aacc4a9 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -23,7 +23,7 @@ use crate::{ use aiur::{ G, execute::{IOBuffer, IOKeyInfo, QueryRecord}, - synthesis::{AiurProof, AiurSystem, CircuitShape}, + synthesis::{AiurProof, AiurSystem, CircuitShape, GatedProve}, }; // ============================================================================= @@ -685,6 +685,34 @@ extern "C" fn rs_aiur_toplevel_check_addrs_with_env( LeanExcept::ok(arr) } +/// Decode a counted address-list blob (`Ix.Cli.CheckCmd.addrListsBlob`): +/// per list, a 4-byte LE count followed by that many 32-byte addresses. +/// The wire format of every partition crossing the FFI (the shard +/// batch, the manifest emit). +pub(crate) fn decode_addr_lists( + bytes: &[u8], +) -> Result>, String> { + let mut lists = Vec::new(); + let mut off = 0usize; + while off < bytes.len() { + if off + 4 > bytes.len() { + return Err("addr lists: truncated count".into()); + } + let n = + u32::from_le_bytes(bytes[off..off + 4].try_into().unwrap()) as usize; + off += 4; + if off + n * 32 > bytes.len() { + return Err("addr lists: truncated addresses".into()); + } + lists.push( + ix_common::address::Address::unpack(&bytes[off..off + n * 32]) + .collect(), + ); + off += n * 32; + } + Ok(lists) +} + /// Byte-weighted admission gate: a counting semaphore over estimated /// execution RSS, expressed with the std Mutex+Condvar construction. /// Bounds MEMORY in flight instead of shards in flight, so the rayon @@ -728,7 +756,27 @@ impl RamGate { /// RSS): 5.7 MB owned -> ~9.6 GB and 1.4 MB -> ~5.5 GB, giving /// ~4 GiB + ~1000x; both terms rounded up for cross-shard spread. const EXEC_RSS_FIXED_BYTES: usize = 9 * (1 << 29); // 4.5 GiB -const EXEC_RSS_PER_OWNED_BYTE: usize = 1100; +// Per-owned-byte execution footprint is ENV-DEPENDENT: ~1000x measured +// on ISLB's shards, ~2300x on Mathlib's (whose constants expand more +// per serialized byte). The gate's contract is NEVER OOM, so the slope +// carries the worst measured env; light envs pay narrower admission, +// not a crash. History: a 1100x slope (ISLB refit) over-admitted a +// 132-shard Mathlib batch to 486/495 GB (OOM, 2026-08-29); the +// original 2500x was itself the fix for the same crash on Mathlib's +// first full-width run (bench-2026-08-22/RESULTS.md), and the 4.5 GiB +// fixed term is ISLB's fix for the inverse small-shard under-reserve. +const EXEC_RSS_PER_OWNED_BYTE: usize = 2500; + +/// Detected prover/execution RAM budget: +/// [`ix_kernel::shard::RAM_USABLE_FRAC`] of `MemAvailable`, reserving +/// the rest for the OS. `None` (no gate) when meminfo is unreadable — +/// disabling the check beats guessing at it. +#[allow(clippy::cast_precision_loss, clippy::cast_possible_truncation)] +#[allow(clippy::cast_sign_loss)] // MemAvailable and the fraction are positive +fn detected_ram_budget() -> Option { + available_ram_bytes() + .map(|b| (b as f64 * ix_kernel::shard::RAM_USABLE_FRAC) as usize) +} /// `MemAvailable` from `/proc/meminfo`, in bytes (Linux; includes /// reclaimable page cache). `None` if unreadable — the caller then @@ -768,10 +816,14 @@ const CONST_WEIGHT_ROW: usize = 48; /// entries name the constants this shard actually checked. The address is /// the LAST input slot — `ci` is passed flattened by value — dereferenced /// through `memory[32]`. `vspan` is the constant's standalone check cost -/// (memo hits replay the callee's recorded span), so the weights are -/// order-independent and stay valid for planning a DIFFERENT partition -/// than the one that measured them. Unconstrained hint rows -/// (multiplicity 0) are skipped: they are not checks. +/// within its shard (memo hits replay the callee's recorded span): +/// order-independent within a partition, but NOT exact across partitions — +/// a callee owned by a foreign shard is assumed rather than replayed, so +/// its span drops out of its callers' rows (measured: ~10% of a 360-const +/// fixture's rows shift between a 1-shard and a 4-shard partition, a few +/// by >2x). Schedule off a profile measured under the partition being +/// scheduled. Unconstrained hint rows (multiplicity 0) are skipped: they +/// are not checks. /// /// Empty unless the execution ran with `profile = true`; without it every /// span reads 0 and the rows carry no signal. @@ -861,29 +913,10 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( let jobs = lean_unbox_nat_as_usize(jobs.inner()); let check_const_idx = lean_unbox_nat_as_usize(check_const_idx.inner()); let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner()); - let mut shards: Vec> = Vec::new(); - { - let bytes = shards_blob.as_bytes(); - let mut off = 0usize; - while off < bytes.len() { - if off + 4 > bytes.len() { - return LeanExcept::error_string("shards_blob: truncated count"); - } - let n = - u32::from_le_bytes(bytes[off..off + 4].try_into().unwrap()) as usize; - off += 4; - if off + n * 32 > bytes.len() { - return LeanExcept::error_string("shards_blob: truncated addresses"); - } - shards.push( - bytes[off..off + n * 32] - .chunks_exact(32) - .map(|c| ix_common::address::Address::from_slice(c).unwrap()) - .collect(), - ); - off += n * 32; - } - } + let shards = match decode_addr_lists(shards_blob.as_bytes()) { + Ok(v) => v, + Err(e) => return LeanExcept::error_string(&e), + }; let env = &env_handle.get().env; // One system build for the whole batch: the RAM model reads circuit // widths and lookup counts off the compiled circuits. @@ -912,7 +945,7 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( let gate = RamGate { reserved: std::sync::Mutex::new(0), cv: std::sync::Condvar::new(), - budget: available_ram_bytes().map_or(usize::MAX, |b| b / 100 * 85), + budget: detected_ram_budget().unwrap_or(usize::MAX), }; { let gib = 1024.0 * 1024.0 * 1024.0; @@ -1169,41 +1202,27 @@ extern "C" fn rs_aiur_system_shard_prove_with_env( // 0 = detect. Matching the check batch's gate keeps one RAM policy in // the system rather than two that can disagree. - let budget = if max_ram_bytes > 0 { - Some(max_ram_bytes) - } else { - available_ram_bytes().map(|b| b / 100 * 85) - }; - // The prove path never profiles. - let executor = |toplevel: &_, fun_idx, input, io_buffer: &mut _| { - ixvm_codegen::aiur_ixvm_runner::execute_ixvm( - toplevel, fun_idx, input, io_buffer, false, - ) - }; - let (proof, peak, parts) = if exec_only { - // Execute + measure, no STARK: `parts` is 1 exactly when the peak - // fits, so the caller's split loop drives off it unchanged. - let (peak, parts) = aiur_system_obj.get().execute_peak_ixvm( - fun_idx, - &input, - &mut io_buffer, - executor, - budget, - ); - (LeanOption::none(), peak, parts) - } else { - match aiur_system_obj.get().prove_ixvm_within_budget( - fun_idx, - &input, - &mut io_buffer, - executor, - budget, - ) { - Ok((_aiur_claim_arr, proof, peak)) => (LeanOption::some( - LeanExternal::alloc(&AIUR_PROOF_CLASS, proof), - ), peak, 1), - Err((peak, parts)) => (LeanOption::none(), peak, parts), - } + let budget = + if max_ram_bytes > 0 { Some(max_ram_bytes) } else { detected_ram_budget() }; + let proved = aiur_system_obj.get().prove_ixvm_within_budget( + fun_idx, + &input, + &mut io_buffer, + // The prove path never profiles. + |toplevel, fun_idx, input, io_buffer| { + ixvm_codegen::aiur_ixvm_runner::execute_ixvm( + toplevel, fun_idx, input, io_buffer, false, + ) + }, + budget, + exec_only, + ); + let (proof, peak, parts) = match proved { + GatedProve::Proved { proof, peak, .. } => (LeanOption::some( + LeanExternal::alloc(&AIUR_PROOF_CLASS, proof), + ), peak, 1), + GatedProve::Split { peak, parts } => (LeanOption::none(), peak, parts), + GatedProve::Measured { peak } => (LeanOption::none(), peak, 1), }; drop(io_buffer); diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index 3c6f9d794..2cb64cc98 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -41,8 +41,9 @@ use lean_ffi::object::LeanNat; use rustc_hash::FxHashMap; use lean_ffi::object::{ - LeanArray, LeanBool, LeanBorrowed, LeanByteArray, LeanIOResult, LeanList, - LeanOption, LeanOwned, LeanProd, LeanRef, LeanString, + LeanArray, LeanBool, LeanBorrowed, LeanByteArray, LeanExternal, + LeanIOResult, LeanList, LeanOption, LeanOwned, LeanProd, LeanRef, + LeanString, }; use crate::lean::LeanIxCheckError; @@ -2389,67 +2390,56 @@ pub extern "C" fn rs_shard_env_static( /// construction (splits partition their parent), so a gap or duplicate /// here is an input error, not a policy choice. /// -/// `peaks_blob`: empty, or one 8-byte LE measured prover peak per -/// shard in shard order — the run's `peak_prove_bytes` measurements, -/// recorded on each manifest shard for schedulers to bin-pack on. +/// `peaks_blob`: one 8-byte LE measured prover peak per shard in shard +/// order — the run's `peak_prove_bytes` measurements, recorded on each +/// manifest shard for schedulers to bin-pack on. +/// +/// Takes the caller's live `EnvHandle`: both call sites hold one for +/// this env already, so the emit costs a profile build, not an env +/// re-parse. #[allow(clippy::cast_possible_truncation)] // block/shard ids are u32 by construction #[unsafe(no_mangle)] pub extern "C" fn rs_shard_manifest_from_partition( - env_path: LeanString>, + env_handle: LeanExternal< + ixvm_codegen::env_handle::EnvHandle, + LeanBorrowed<'_>, + >, shards_blob: LeanByteArray>, peaks_blob: LeanByteArray>, out_path: LeanString>, ) -> LeanIOResult { - let path = env_path.to_string(); let out = out_path.to_string(); - let env = match IxonEnv::get_anon_mmap(std::path::Path::new(&path)) { - Ok(e) => e, - Err(e) => { - return LeanIOResult::error_string(&format!( - "rs_shard_manifest_from_partition: failed to load {path}: {e}" - )); - }, - }; - let profile = static_block_profile(&env); + let profile = static_block_profile(&env_handle.get().env); let block_id: FxHashMap = profile .blocks() .iter() .enumerate() .map(|(i, b)| (b.addr.clone(), i as u32)) .collect(); - let bytes = shards_blob.as_bytes(); + let lists = + match crate::aiur::protocol::decode_addr_lists(shards_blob.as_bytes()) { + Ok(v) => v, + Err(e) => return LeanIOResult::error_string(&e), + }; + let num_shards = lists.len(); let mut shard_of = vec![u32::MAX; profile.num_blocks()]; - let mut num_shards = 0usize; - let mut off = 0usize; - while off < bytes.len() { - if off + 4 > bytes.len() { - return LeanIOResult::error_string("shards_blob: truncated count"); - } - let n = - u32::from_le_bytes(bytes[off..off + 4].try_into().unwrap()) as usize; - off += 4; - if off + n * 32 > bytes.len() { - return LeanIOResult::error_string("shards_blob: truncated addresses"); - } - for c in bytes[off..off + n * 32].chunks_exact(32) { - let addr = Address::from_slice(c).unwrap(); - let Some(&b) = block_id.get(&addr) else { + for (k, list) in lists.iter().enumerate() { + for addr in list { + let Some(&b) = block_id.get(addr) else { return LeanIOResult::error_string(&format!( - "shard {num_shards}: block {} not in the env's block profile", + "shard {k}: block {} not in the env's block profile", addr.hex() )); }; if shard_of[b as usize] != u32::MAX { return LeanIOResult::error_string(&format!( - "block {} appears in shards {} and {num_shards}", + "block {} appears in shards {} and {k}", addr.hex(), shard_of[b as usize] )); } - shard_of[b as usize] = num_shards as u32; + shard_of[b as usize] = k as u32; } - off += n * 32; - num_shards += 1; } let uncovered = shard_of.iter().filter(|&&s| s == u32::MAX).count(); if uncovered > 0 { diff --git a/crates/kernel/src/shard.rs b/crates/kernel/src/shard.rs index 7f1ef1c80..b77283156 100644 --- a/crates/kernel/src/shard.rs +++ b/crates/kernel/src/shard.rs @@ -1389,9 +1389,28 @@ impl ShardManifest { let empty = self.shards.iter().filter(|s| s.blocks.is_empty()).count(); let max_cross = self.shards.iter().map(|s| s.cross_ingress).max().unwrap_or(0); + let peaks: Vec = self + .shards + .iter() + .map(|s| s.measured_peak_bytes) + .filter(|&p| p != 0) + .collect(); + #[allow(clippy::cast_precision_loss)] + let measured = if peaks.is_empty() { + String::new() + } else { + let gib = |b: u64| b as f64 / (1u64 << 30) as f64; + format!( + " measured-peaks[{}/{} shards, min={:.1} max={:.1} GiB]", + peaks.len(), + self.shards.len(), + gib(peaks.iter().copied().min().unwrap_or(0)), + gib(peaks.iter().copied().max().unwrap_or(0)), + ) + }; format!( "shards={} (empty={}) heartbeats[min={} mean={} max={}] imbalance={:.2}x \ - cross_ingress_total={} max_shard_cross={}", + cross_ingress_total={} max_shard_cross={}{measured}", self.shards.len(), empty, min, @@ -1442,9 +1461,15 @@ impl ShardManifest { } // Trailing measured-peaks section (same older-readers-ignore contract // as the tree): presence byte, then one u64 LE per shard in order. - out.push(1); - for sh in &self.shards { - out.extend_from_slice(&sh.measured_peak_bytes.to_le_bytes()); + // Absent when nothing was measured, so planner manifests stay + // byte-identical to the pre-peaks format. + if self.shards.iter().any(|s| s.measured_peak_bytes != 0) { + out.push(1); + for sh in &self.shards { + out.extend_from_slice(&sh.measured_peak_bytes.to_le_bytes()); + } + } else { + out.push(0); } out } @@ -1816,14 +1841,7 @@ pub fn shard_static( ); let mut manifest = ShardManifest::build(profile, &shard_of, num_shards).with_tree(tree); - for shard in &mut manifest.shards { - shard.assumption_root = - ixon::merkle::merkle_root_canonical(&shard.foreign_blocks); - } - if let Some(op) = out_path { - std::fs::write(op, manifest.to_bytes()) - .map_err(|e| format!("write {op}: {e}"))?; - } + seal_and_write(&mut manifest, out_path)?; let costs = static_predicted_costs(profile, &shard_of, num_shards); let (mut lo, mut hi, mut sum) = (f64::INFINITY, 0.0f64, 0.0f64); for &c in &costs { @@ -1868,14 +1886,7 @@ pub fn shard_esp( let (shard_of, tree) = h.partition_with_tree(num_shards, balance); let mut manifest = ShardManifest::build(&profile, &shard_of, num_shards).with_tree(tree); - for shard in &mut manifest.shards { - shard.assumption_root = - ixon::merkle::merkle_root_canonical(&shard.foreign_blocks); - } - if let Some(op) = out_path { - std::fs::write(op, manifest.to_bytes()) - .map_err(|e| format!("write {op}: {e}"))?; - } + seal_and_write(&mut manifest, out_path)?; // The largest single block's heartbeats is the *floor* on achievable // per-shard balance: a mutual block is atomic and cannot be split, so no // partition can drive max-shard heartbeats below it. When the heaviest shard @@ -1904,6 +1915,24 @@ pub fn shard_esp( )) } +/// Seal every shard's assumption root (the canonical merkle root over +/// its foreign blocks) and write the manifest when a path is given. +/// Shared tail of every manifest-producing entry point. +fn seal_and_write( + manifest: &mut ShardManifest, + out_path: Option<&str>, +) -> Result<(), String> { + for shard in &mut manifest.shards { + shard.assumption_root = + ixon::merkle::merkle_root_canonical(&shard.foreign_blocks); + } + if let Some(op) = out_path { + std::fs::write(op, manifest.to_bytes()) + .map_err(|e| format!("write {op}: {e}"))?; + } + Ok(()) +} + /// Write a `.ixes` manifest for an EXPLICIT shard assignment — the /// partition a prove run actually produced (splits included) rather /// than a planner's output. Same manifest construction as @@ -1923,20 +1952,17 @@ pub fn shard_manifest_explicit( peaks: &[u64], out_path: &str, ) -> Result { - if !peaks.is_empty() && peaks.len() != num_shards { + if peaks.len() != num_shards { return Err(format!( "measured peaks: {} values for {num_shards} shards", peaks.len() )); } let mut manifest = ShardManifest::build(profile, shard_of, num_shards); - for (i, shard) in manifest.shards.iter_mut().enumerate() { - shard.assumption_root = - ixon::merkle::merkle_root_canonical(&shard.foreign_blocks); - shard.measured_peak_bytes = peaks.get(i).copied().unwrap_or(0); + for (shard, &peak) in manifest.shards.iter_mut().zip(peaks) { + shard.measured_peak_bytes = peak; } - std::fs::write(out_path, manifest.to_bytes()) - .map_err(|e| format!("write {out_path}: {e}"))?; + seal_and_write(&mut manifest, Some(out_path))?; Ok(manifest.summary()) } @@ -1959,14 +1985,7 @@ pub fn shard_esp_cap( let mut manifest = ShardManifest::build(&profile, &plan.shard_of, plan.num_shards) .with_tree(plan.tree); - for shard in &mut manifest.shards { - shard.assumption_root = - ixon::merkle::merkle_root_canonical(&shard.foreign_blocks); - } - if let Some(op) = out_path { - std::fs::write(op, manifest.to_bytes()) - .map_err(|e| format!("write {op}: {e}"))?; - } + seal_and_write(&mut manifest, out_path)?; let note = if plan.infeasible_atomic_floor { "\n [INFEASIBLE: a single atomic block exceeds the cap — split it upstream, raise the cap, or use a bigger box]" } else { From 5646af6e2674998696ff3ca6d9134a2a0190e892 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Fri, 28 Aug 2026 11:48:09 -0400 Subject: [PATCH 09/44] feat: add verified aggregate proof cache Precompute versioned per-slot cache keys, persist lift and join wrappers in the content-addressed store, and reuse entries only after exact claim and native outer-proof verification. Add safe proof decoding, corruption recovery, and --no-cache. --- Ix/Aiur/Protocol.lean | 6 + Ix/Cli/AggregateCmd.lean | 343 ++++++++++++++++++++++++++------ Ix/Store.lean | 10 + Tests/MultiStark.lean | 129 ++++++++++++ crates/ffi/src/aiur/protocol.rs | 21 ++ 5 files changed, 449 insertions(+), 60 deletions(-) diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 322ebad65..d1f5a913a 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -25,6 +25,12 @@ opaque toBytes : @& Proof → ByteArray @[extern "rs_aiur_proof_of_bytes"] opaque ofBytes : @& ByteArray → Proof +/-- Decode an untrusted serialized proof without aborting the process. Cache +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 diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index 04bb32658..0c9b42367 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -9,9 +9,9 @@ persisted wrapper carries the aggregate `CheckEnv` claim and recursive proof bytes. - This first host driver is intentionally serial and cache-free. Its slot - model and content-addressed inputs make parallel scheduling and resumable - cache entries follow-up optimizations rather than protocol changes. + The host driver remains serial, but every completed lift/join is persisted in + a verified, content-addressed resume cache. Parallel slot scheduling remains + a follow-up optimization rather than a protocol change. -/ module public import Cli @@ -36,10 +36,29 @@ structure AggregateSlot where subjectCount : Nat outerClaim : Array Aiur.G proof : Aiur.Proof + proofAddress? : Option Address /-- Preimages needed when this slot is decoded by its parent. A lift exposes its inner claims plus `CheckEnv`; a join exposes only its output `CheckEnv`. -/ openPreimages : Array ByteArray +/-- Everything claim-derived about a slot, computed for the whole fold before +the first cache lookup or proof. -/ +structure AggregateSlotSpec where + 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 @@ -50,6 +69,66 @@ structure ScheduledFold where def defaultStructuralAbove : Nat := 4096 +/-- Bump when aggregate advice framing changes without changing the recursion +verifying key. Encoded as `u64` little-endian in every cache key. -/ +def aggregateCacheVersion : Nat := 1 + +/-- +`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 already commits to the entrypoint and public +input; joins therefore transitively pin the allowed blob and output statement. +-/ +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. -/ @@ -74,6 +153,64 @@ def schedulePlan (plan : Array Ix.Cli.CheckCmd.AggregationTree.FoldOp) } pure scheduled +/-- Derive every slot statement, outer claim, and cache key before proving. +This makes resume independent of execution order and lets manifest changes +invalidate only the claim-changed subtree. -/ +def buildAggregateSlotSpecs (plan : Array ScheduledFold) + (prepared : Array PreparedShard) (ixvmVk recursionVk allowed : ByteArray) + (verifyIdx liftIdx joinIdx structuralJoinIdx : 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 innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] + let pubInput := MultiStark.verifierPubInput ixvmVk innerClaimsBytes + let outerClaim := Aiur.buildClaim liftIdx pubInput #[] + specs := specs.push { + statement := preparedShard.statement + subjectCount := item.subjectCount + outerClaim + cacheKey := aggregateCacheKey recursionVk 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 output := if item.structural then + left.statement.joinStructural right.statement + else + left.statement.join right.statement + if output.subjectCount != item.subjectCount then + throw s!"aggregate join reconstructs {output.subjectCount} subjects, \ + but the schedule records {item.subjectCount}" + let outputClaimBytes := Ix.Claim.ser output.claim + let pubInput := MultiStark.joinPubInput allowed outputClaimBytes + let joinFunIdx := if item.structural then structuralJoinIdx else joinIdx + let outerClaim := Aiur.buildClaim joinFunIdx pubInput #[] + specs := specs.push { + statement := output + subjectCount := item.subjectCount + outerClaim + cacheKey := aggregateCacheKey recursionVk recursionParameters outerClaim + } + pure specs + private def addrOfHex (label value : String) : Except String Address := match Address.fromString value with | some address => .ok address @@ -96,6 +233,61 @@ private def compileToplevel (label : String) | .error e => return Except.error s!"{label} compilation failed: {e}" | .ok compiled => return Except.ok compiled +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 lifts := plan.countP fun item => match item.op with @@ -220,9 +412,21 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) let recursionVk := recursionSystem.vkBytes let allowed := MultiStark.allowedBlob ixvmVk verifyIdx recursionVk liftIdx joinIdx structuralJoinIdx + let specs ← match buildAggregateSlotSpecs plan prepared ixvmVk recursionVk allowed + verifyIdx liftIdx joinIdx structuralJoinIdx 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 mut slots : Array AggregateSlot := #[] for (item, slotIdx) in plan.mapIdx fun slotIdx item => (item, slotIdx) do + let some spec := specs[slotIdx]? | do + IO.eprintln s!"internal: missing prepared aggregate slot {slotIdx}" + return 1 match item.op with | .leaf shard => let originalShard := (view.shardIds[shard]?).getD shard @@ -232,10 +436,6 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) let some preparedShard := prepared[shard]? | do IO.eprintln s!"internal: no statement for shard {originalShard}" return 1 - if preparedShard.statement.subjectCount != item.subjectCount then - IO.eprintln s!"internal: shard {originalShard} has {preparedShard.statement.subjectCount} \ - reconstructed subjects, but the schedule records {item.subjectCount}" - return 1 let claimBytes := Ix.Claim.ser preparedShard.claim let verifyInput := IxVM.ClaimHarness.packedDigestKey (Address.blake3 claimBytes) @@ -247,16 +447,30 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) return 1 | .ok () => pure () let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] - let pubInput := MultiStark.verifierPubInput ixvmVk innerClaimsBytes - IO.println s!"[aggregate] lifting shard {originalShard} into slot {slotIdx}" - (← IO.getStdout).flush - let (outerClaim, proof) := recursionSystem.proveMultiStark liftIdx pubInput - wrapper.proof ixvmVk innerClaimsBytes + let cached? ← match cacheDir? with + | none => pure none + | some dir => loadCachedAggregateProof dir slotIdx spec recursionSystem + let (proof, proofAddress?) ← match cached? with + | some cached => pure (cached.proof, some cached.address) + | none => + let pubInput := MultiStark.verifierPubInput ixvmVk innerClaimsBytes + IO.println s!"[aggregate] lifting shard {originalShard} into slot {slotIdx}" + (← IO.getStdout).flush + let (outerClaim, proof) := recursionSystem.proveMultiStark liftIdx pubInput + wrapper.proof ixvmVk innerClaimsBytes + if outerClaim != spec.outerClaim then + IO.eprintln s!"internal: lift slot {slotIdx} produced an unexpected outer claim" + return 1 + let proofAddress? ← match cacheDir? with + | none => pure none + | some dir => persistAggregateCacheProof dir slotIdx spec proof + pure (proof, proofAddress?) slots := slots.push { - statement := preparedShard.statement - subjectCount := item.subjectCount - outerClaim + statement := spec.statement + subjectCount := spec.subjectCount + outerClaim := spec.outerClaim proof + proofAddress? openPreimages := #[innerClaimsBytes, claimBytes] } | .join leftIdx rightIdx => @@ -266,51 +480,56 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) let some right := slots[rightIdx]? | do IO.eprintln s!"invalid aggregate plan: missing right slot {rightIdx}" return 1 - if left.subjectCount + right.subjectCount != item.subjectCount then - IO.eprintln s!"internal: join slot {slotIdx} has inconsistent scheduled subject counts" - return 1 - let output := if item.structural then - left.statement.joinStructural right.statement - else - left.statement.join right.statement - if output.subjectCount != item.subjectCount then - IO.eprintln s!"internal: join slot {slotIdx} reconstructed {output.subjectCount} \ - subjects, but the schedule records {item.subjectCount}" - return 1 + let output := spec.statement let outputClaimBytes := Ix.Claim.ser output.claim - let pubInput := MultiStark.joinPubInput allowed outputClaimBytes - let leftClaimsBytes := MultiStark.serializeClaims #[left.outerClaim] - let rightClaimsBytes := MultiStark.serializeClaims #[right.outerClaim] - let preimagesBlob := MultiStark.joinPreimagesBlob - (left.openPreimages ++ right.openPreimages) - let trees := if item.structural then - MultiStark.CheckEnvTrees.structuralAdviceTrees - left.statement right.statement output - else - MultiStark.CheckEnvTrees.adviceTrees left.statement right.statement output - let treesBlob := MultiStark.joinTreesBlob trees - let pathsBlob := if item.structural then - MultiStark.joinPathsBlob - (MultiStark.CheckEnvTrees.structuralPathAdvice - left.statement right.statement output) - else - MultiStark.joinPathsBlob #[] - let joinFunIdx := if item.structural then structuralJoinIdx else joinIdx - let mode := if item.structural then "structural" else "flat" - IO.println s!"[aggregate] {mode}-joining slots {leftIdx}, {rightIdx} into {slotIdx}" - (← IO.getStdout).flush - let result := recursionSystem.proveMultiStarkJoin joinFunIdx pubInput - left.proof.toBytes right.proof.toBytes recursionVk - leftClaimsBytes rightClaimsBytes outputClaimBytes allowed - preimagesBlob treesBlob pathsBlob - let (outerClaim, proof) ← match result with - | .error e => IO.eprintln s!"join slot {slotIdx}: {e}"; return 1 - | .ok result => pure result + let cached? ← match cacheDir? with + | none => pure none + | some dir => loadCachedAggregateProof dir slotIdx spec recursionSystem + let (proof, proofAddress?) ← match cached? with + | some cached => pure (cached.proof, some cached.address) + | none => + let pubInput := MultiStark.joinPubInput allowed outputClaimBytes + let leftClaimsBytes := MultiStark.serializeClaims #[left.outerClaim] + let rightClaimsBytes := MultiStark.serializeClaims #[right.outerClaim] + let preimagesBlob := MultiStark.joinPreimagesBlob + (left.openPreimages ++ right.openPreimages) + let trees := if item.structural then + MultiStark.CheckEnvTrees.structuralAdviceTrees + left.statement right.statement output + else + MultiStark.CheckEnvTrees.adviceTrees + left.statement right.statement output + let treesBlob := MultiStark.joinTreesBlob trees + let pathsBlob := if item.structural then + MultiStark.joinPathsBlob + (MultiStark.CheckEnvTrees.structuralPathAdvice + left.statement right.statement output) + else + MultiStark.joinPathsBlob #[] + let joinFunIdx := if item.structural then structuralJoinIdx else joinIdx + let mode := if item.structural then "structural" else "flat" + IO.println s!"[aggregate] {mode}-joining slots {leftIdx}, {rightIdx} into {slotIdx}" + (← IO.getStdout).flush + let result := recursionSystem.proveMultiStarkJoin joinFunIdx pubInput + left.proof.toBytes right.proof.toBytes recursionVk + leftClaimsBytes rightClaimsBytes outputClaimBytes allowed + preimagesBlob treesBlob pathsBlob + let (outerClaim, proof) ← match result with + | .error e => IO.eprintln s!"join slot {slotIdx}: {e}"; return 1 + | .ok result => pure result + if outerClaim != spec.outerClaim then + IO.eprintln s!"internal: join slot {slotIdx} produced an unexpected outer claim" + return 1 + let proofAddress? ← match cacheDir? with + | none => pure none + | some dir => persistAggregateCacheProof dir slotIdx spec proof + pure (proof, proofAddress?) slots := slots.push { statement := output - subjectCount := item.subjectCount - outerClaim + subjectCount := spec.subjectCount + outerClaim := spec.outerClaim proof + proofAddress? openPreimages := #[outputClaimBytes] } @@ -333,10 +552,13 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) | .error e => IO.eprintln s!"aggregate root proof failed native verification: {e}"; return 1 | .ok () => pure () - let claim := root.statement.claim - let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) - let wrapper : Ixon.Proof := { claim, proof := root.proof.toBytes } - let proofAddress ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) + 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 @@ -354,6 +576,7 @@ def aggregateCmd : Cli.Cmd := `[Cli| "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 lift/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." "structural-above" : Nat; "Use structural joins when a node contains more than N subject leaves (default 4096; 0 means every join)." ARGS: 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/` 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/Tests/MultiStark.lean b/Tests/MultiStark.lean index 74bac7143..c7613cb5b 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -397,6 +397,71 @@ def joinSmokeSuite : IO UInt32 := do 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 := Ix.Cli.VerifyCmd.aggregateLiftOuterClaim fakeIxvmVk verifyIdx liftIdx leftStatement.claim @@ -405,6 +470,48 @@ def joinSmokeSuite : IO UInt32 := do 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 } + ] + let cachePrepared : Array Ix.Cli.AggregateCmd.PreparedShard := #[ + { claim := leftStatement.claim, statement := leftStatement }, + { claim := rightStatement.claim, statement := rightStatement } + ] + let cacheSpecs := Ix.Cli.AggregateCmd.buildAggregateSlotSpecs cachePlan + cachePrepared fakeIxvmVk recursionVk allowed verifyIdx liftIdx childJoinIdx + childStructuralJoinIdx childRecursionParameters + let cacheSpecsComplete : Bool := match cacheSpecs with + | .ok specs => match specs[0]?, specs[1]?, specs[2]? with + | some left, some right, some root => + specs.size == 3 && left.outerClaim == leftOuter && + right.outerClaim == rightOuter && + root.statement.claim == outputStatement.claim && + root.outerClaim == Aiur.buildClaim childJoinIdx pubInput #[] && + left.cacheKey == liftCacheKey + | _, _, _ => false + | .error _ => false + let cachedLiftBytes := Ixon.Proof.ser cachedLiftWrapper + let resumedLift? ← match cacheSpecs with + | .ok specs => + match specs[0]? with + | some spec => + Ix.Cli.AggregateCmd.loadCachedAggregateProofWith + (fun _ => pure cachedLiftBytes) cacheDir 0 spec childSystem + | none => pure none + | .error _ => pure none + let corruptStoreLift? ← match cacheSpecs with + | .ok specs => + match specs[0]? with + | some spec => + Ix.Cli.AggregateCmd.loadCachedAggregateProofWith + (fun _ => pure (cachedLiftBytes.push 0xff)) + cacheDir 0 spec childSystem + | none => pure none + | .error _ => pure none + let verifiedResumeHit := resumedLift?.isSome + let corruptStoreFallsThrough := corruptStoreLift?.isNone let leftOuterBytes := MultiStark.serializeClaims #[leftOuter] let rightOuterBytes := MultiStark.serializeClaims #[rightOuter] @@ -713,6 +820,28 @@ def joinSmokeSuite : IO UInt32 := do 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 "all aggregate slot claims and cache keys are prepared before proving" + cacheSpecsComplete, + 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, diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 9f9285a67..c7681563c 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>, +) -> LeanExcept { + 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`) — see From 20f5e62dc8a185a9a6eb0e513634432631ca03a7 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Fri, 28 Aug 2026 16:06:52 +0000 Subject: [PATCH 10/44] bench: aiur-sharded-env exercises the split audit The backend passes the same 100 GiB runner budget to both stages: ix shard seeds for it and ix check --ram-budget cuts any seed the spread pushes over it in place, so the row's shards metric counts the leaf partition the run actually validated. The measured check-time window stays the wave-0 batch call, keeping the timing metric comparable; a shards increase on first run reflects real splits at this budget and takes a one-time re-pin. --- Ix/Cli/BenchCmd.lean | 32 ++++++++++++++++---------- crates/ffi/src/aiur/protocol.rs | 40 ++++++++++++++++++++++----------- 2 files changed, 47 insertions(+), 25 deletions(-) diff --git a/Ix/Cli/BenchCmd.lean b/Ix/Cli/BenchCmd.lean index f43c9a932..9d74c5639 100644 --- a/Ix/Cli/BenchCmd.lean +++ b/Ix/Cli/BenchCmd.lean @@ -276,16 +276,18 @@ def backendSpecs : List BackendSpec := [ ("fri-verifier-verify-time", "0.10", "_")] }, -- aiur-sharded-env: whole-env Aiur execution — the sharded feeder pipeline -- end-to-end at env scale, one row per env. Shards the `.ixe` for the - -- runner's RAM (`ix shard --max-ram 100`: naive sizing → ~3.5 GB - -- execution RSS per shard on a 128 GB runner), then one gated - -- full-width rayon batch (`ix check --ixe --ixes`) over the whole - -- manifest — the byte-weighted RamGate, not a thread cap, bounds peak - -- RSS, so the same entry is correct on any runner class. ISLB only - -- for now (~10 min/run); add "FLT" / "Mathlib" to `envs` for the - -- env-scale tiers (~30-45 min each on the 32x runner) when their - -- per-push cost is warranted. `shards` is deterministic per - -- (env bytes, budget) and only drops on a real compression win → - -- upper-only pin. + -- runner's RAM (`ix shard --max-ram 100`: seed sizing), then one gated + -- full-width rayon batch with the split audit (`ix check --ram-budget + -- 100`): a seed the spread pushes over the budget is cut in place and + -- its parts re-measured, so the row describes the LEAF partition the + -- run validated. The byte-weighted RamGate, not a thread cap, bounds + -- peak RSS, so the same entry is correct on any runner class. The + -- measured window (`check-time`) is the wave-0 batch call; split + -- waves are audit extras outside it. ISLB only for now (~10 min/run); + -- add "FLT" / "Mathlib" to `envs` for the env-scale tiers when their + -- per-push cost is warranted. `shards` counts leaves — deterministic + -- per (env bytes, budget), rising only when the seed under-counts → + -- upper-only pin, re-pin on a justified seed or split change. { name := "aiur-sharded-env", defaultMode := "execute", inputs := .perEnv, envs := some ["ISLB"], testbeds := [("execute", "aiur-sharded-env-check-x64-32x")], @@ -757,13 +759,19 @@ is not a benchmark run" let ixe ← ensureIxe repo info ((p.flag? "ixe").map (·.as! String)) let ix ← resolveBin repo "ix" let manifest := s!"{env}-exec.ixes" + -- One budget for both stages: the shard step seeds for it, and the + -- check's split audit (`--ram-budget`) cuts any seed the spread + -- pushes over it in place — the row's `shards` counts the LEAF + -- partition the run actually validated. 100 GiB = the 128 GB + -- runner class the testbed pins. + let budgetGib := "100" let exit ← runGuarded watchdog ceilingGb ix - #["shard", ixe, "--max-ram", "100", "--out", manifest] + #["shard", ixe, "--max-ram", budgetGib, "--out", manifest] if exit != 0 then IO.eprintln s!"[bench] ix shard failed (exit {exit})" return 1 let exit ← runGuarded watchdog ceilingGb ix - #["check", "--ixe", ixe, "--ixes", manifest, + #["check", "--ixe", ixe, "--ixes", manifest, "--ram-budget", budgetGib, "--json", out, "--json-name", info.name] if exit != 0 && exit != exitRejected then IO.eprintln s!"[bench] whole-env aiur check failed (exit {exit})" diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index d7aacc4a9..cc3d31466 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -756,16 +756,31 @@ impl RamGate { /// RSS): 5.7 MB owned -> ~9.6 GB and 1.4 MB -> ~5.5 GB, giving /// ~4 GiB + ~1000x; both terms rounded up for cross-shard spread. const EXEC_RSS_FIXED_BYTES: usize = 9 * (1 << 29); // 4.5 GiB -// Per-owned-byte execution footprint is ENV-DEPENDENT: ~1000x measured -// on ISLB's shards, ~2300x on Mathlib's (whose constants expand more -// per serialized byte). The gate's contract is NEVER OOM, so the slope -// carries the worst measured env; light envs pay narrower admission, -// not a crash. History: a 1100x slope (ISLB refit) over-admitted a -// 132-shard Mathlib batch to 486/495 GB (OOM, 2026-08-29); the -// original 2500x was itself the fix for the same crash on Mathlib's -// first full-width run (bench-2026-08-22/RESULTS.md), and the 4.5 GiB -// fixed term is ISLB's fix for the inverse small-shard under-reserve. -const EXEC_RSS_PER_OWNED_BYTE: usize = 2500; +// Two calibrations, each accurate in its own regime, combined as a MAX +// in `exec_rss_estimate` because the per-owned-byte execution footprint +// is env-dependent and the gate's contract is NEVER OOM: +// - The affine fit (4.5 GiB + 1100x) measured on ISLB's small shards +// (1.4-5.7 MB owned; a pure ratio under-reserved them and OOM'd a +// 128 GB box). +// - The pure ratio (2500x, ~2300x measured + margin) validated on +// Mathlib's full-width 233-shard batch at +2% of estimate; the +// affine slope alone under-reserved Mathlib-class shards and +// over-admitted a 132-shard full-width batch to 486/495 GB +// (OOM, 2026-08-29 — the first Mathlib full-width run under the +// affine constant). +// The max reproduces each fit where it was measured: small shards take +// the affine branch (ISLB bench reservations unchanged), large shards +// the ratio branch. +const EXEC_RSS_PER_OWNED_BYTE: usize = 1100; +const EXEC_RSS_RATIO_PER_OWNED_BYTE: usize = 2500; + +/// Per-shard execution-RSS reserve: the max of the two measured fits +/// (see the constants above). +fn exec_rss_estimate(owned_bytes: usize) -> usize { + EXEC_RSS_FIXED_BYTES + .saturating_add(owned_bytes.saturating_mul(EXEC_RSS_PER_OWNED_BYTE)) + .max(owned_bytes.saturating_mul(EXEC_RSS_RATIO_PER_OWNED_BYTE)) +} /// Detected prover/execution RAM budget: /// [`ix_kernel::shard::RAM_USABLE_FRAC`] of `MemAvailable`, reserving @@ -933,12 +948,11 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( let estimates: Vec = shards .iter() .map(|owned| { - EXEC_RSS_FIXED_BYTES.saturating_add( + exec_rss_estimate( owned .iter() .filter_map(|a| env.get_const_bytes(a).map(|b| b.len())) - .sum::() - .saturating_mul(EXEC_RSS_PER_OWNED_BYTE), + .sum::(), ) }) .collect(); From 614cf55955a9d7e3c2c69748907cf3daaa200ac7 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Fri, 28 Aug 2026 18:17:49 +0000 Subject: [PATCH 11/44] perf(aggregate): avoid repeated shard closure walks --- Ix/Cli/AggregateCmd.lean | 2 +- Ix/Cli/CheckCmd.lean | 3 ++- Ix/Cli/VerifyCmd.lean | 2 +- Ix/IxVM/ClaimHarness.lean | 32 +++++++++++++++++++---------- Tests/MultiStark.lean | 42 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 68 insertions(+), 13 deletions(-) diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index 0c9b42367..2090de91d 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -220,7 +220,7 @@ private def addrOfHex (label value : String) : Except String Address := 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.shardCheckEnvClaim env owned + let (claim, trees) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned let statement ← MultiStark.CheckEnvTrees.ofClaim claim trees pure { claim, statement } diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 58dec519b..57d16a582 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -644,7 +644,8 @@ def IxesManifestView.pruneEmpty (view : IxesManifestView) 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/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean index b48f2442a..ff410f780 100644 --- a/Ix/Cli/VerifyCmd.lean +++ b/Ix/Cli/VerifyCmd.lean @@ -140,7 +140,7 @@ private def buildAggregateBackend private def shardStatement (env : Ixon.Env) (blocks : Array Address) : Except String MultiStark.CheckEnvTrees := do let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks env blocks - let (claim, _, trees) ← IxVM.ClaimHarness.shardCheckEnvClaim env owned + let (claim, trees) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned MultiStark.CheckEnvTrees.ofClaim claim trees /-- Reproduce the lift/flat/structural statement fold from a coverage-validated 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/Tests/MultiStark.lean b/Tests/MultiStark.lean index c7613cb5b..ed472926b 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -300,6 +300,23 @@ private def singletonIxonEnv : Ixon.Env × Address := 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! @@ -803,6 +820,29 @@ def joinSmokeSuite : IO UInt32 := do 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 => @@ -850,6 +890,8 @@ def joinSmokeSuite : IO UInt32 := do test "empty manifest leaves contract and retained ids remap densely" emptyPruningCorrect, test "one retained shard folds to a lift root" singleManifestLiftRoot, + 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), From a3372b617cec740e578d6e137649a7cb69dc3c86 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Fri, 28 Aug 2026 13:27:39 -0400 Subject: [PATCH 12/44] feat: parallelize aggregate proof scheduling Execute ready lift and join slots as a dependency DAG under explicit job and RAM admission. Add calibration-pending slot weights, failure draining, CLI controls, and serial/parallel scheduler and proof-equivalence gates. --- Ix/Cli/AggregateCmd.lean | 541 +++++++++++++++++++++++++++++++-------- Tests/MultiStark.lean | 172 +++++++++++++ 2 files changed, 600 insertions(+), 113 deletions(-) diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index 2090de91d..467367125 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -9,11 +9,12 @@ persisted wrapper carries the aggregate `CheckEnv` claim and recursive proof bytes. - The host driver remains serial, but every completed lift/join is persisted in - a verified, content-addressed resume cache. Parallel slot scheduling remains - a follow-up optimization rather than a protocol change. + The host driver schedules the fold as a dependency DAG. Ready slots run on + dedicated tasks under explicit job and RAM reservations; every completed + lift/join is persisted in a verified, content-addressed resume cache. -/ module +import Std.Sync public import Cli public import Ix.Cli.CheckCmd public import Ix.IxVM @@ -67,8 +68,159 @@ structure ScheduledFold where structural : Bool 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 + +/-- 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 + +/-- 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 + +/-- Calibration-pending per-slot RAM weight used by the Lean admission gate. -/ +def aggregateSlotRamBytes (item : ScheduledFold) : Nat := + match item.op with + | .leaf _ => aggregateLiftRamBytes + | .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 advice framing changes without changing the recursion verifying key. Encoded as `u64` little-endian in every cache key. -/ def aggregateCacheVersion : Nat := 1 @@ -233,6 +385,124 @@ private def compileToplevel (label : String) | .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) : @@ -306,6 +576,135 @@ private def printPlan (plan : Array ScheduledFold) (shardIds : Array Nat) IO.println s!" slot {slot}: {mode} join 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 + recursionSystem : Aiur.AiurSystem + ixvmVk : ByteArray + recursionVk : ByteArray + allowed : ByteArray + verifyIdx : Aiur.Bytecode.FunIdx + liftIdx : Aiur.Bytecode.FunIdx + joinIdx : Aiur.Bytecode.FunIdx + structuralJoinIdx : 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] + let cached? ← match ctx.cacheDir? with + | none => pure none + | some dir => loadCachedAggregateProof dir slotIdx spec ctx.recursionSystem + let (proof, proofAddress?) ← match cached? with + | some cached => pure (cached.proof, some cached.address) + | none => + let pubInput := MultiStark.verifierPubInput ctx.ixvmVk innerClaimsBytes + IO.println s!"[aggregate] lifting shard {originalShard} into slot {slotIdx}" + (← IO.getStdout).flush + let (outerClaim, proof) := ctx.recursionSystem.proveMultiStark + ctx.liftIdx pubInput wrapper.proof ctx.ixvmVk innerClaimsBytes + if outerClaim != spec.outerClaim then + return .error "lift 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 { + statement := spec.statement + subjectCount := spec.subjectCount + outerClaim := spec.outerClaim + proof + proofAddress? + openPreimages := #[innerClaimsBytes, claimBytes] + } + | .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.recursionSystem + let (proof, proofAddress?) ← match cached? with + | some cached => pure (cached.proof, some cached.address) + | none => + let pubInput := MultiStark.joinPubInput ctx.allowed outputClaimBytes + let leftClaimsBytes := MultiStark.serializeClaims #[left.outerClaim] + let rightClaimsBytes := MultiStark.serializeClaims #[right.outerClaim] + let preimagesBlob := MultiStark.joinPreimagesBlob + (left.openPreimages ++ right.openPreimages) + let trees := if item.structural then + MultiStark.CheckEnvTrees.structuralAdviceTrees + left.statement right.statement output + else + MultiStark.CheckEnvTrees.adviceTrees + left.statement right.statement output + let treesBlob := MultiStark.joinTreesBlob trees + let pathsBlob := if item.structural then + MultiStark.joinPathsBlob + (MultiStark.CheckEnvTrees.structuralPathAdvice + left.statement right.statement output) + else + MultiStark.joinPathsBlob #[] + let joinFunIdx := if item.structural then ctx.structuralJoinIdx else ctx.joinIdx + let mode := if item.structural then "structural" else "flat" + IO.println s!"[aggregate] {mode}-joining slots {leftIdx}, {rightIdx} into {slotIdx}" + (← IO.getStdout).flush + let result := ctx.recursionSystem.proveMultiStarkJoin joinFunIdx pubInput + left.proof.toBytes right.proof.toBytes ctx.recursionVk + 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 { + statement := output + subjectCount := spec.subjectCount + outerClaim := spec.outerClaim + proof + proofAddress? + openPreimages := #[outputClaimBytes] + } + /-- 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 @@ -340,6 +739,21 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) | .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}); \ + lift/structural reserve {formatAggregateGiB aggregateLiftRamBytes} GiB, \ + flat +1 MiB/subject (calibration pending)" if p.hasFlag "plan-only" then return 0 let proofHexes := (p.variableArgsAs! String).toList @@ -422,116 +836,15 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) else pure (some (← aggregateCacheDir)) - let mut slots : Array AggregateSlot := #[] - for (item, slotIdx) in plan.mapIdx fun slotIdx item => (item, slotIdx) do - let some spec := specs[slotIdx]? | do - IO.eprintln s!"internal: missing prepared aggregate slot {slotIdx}" - return 1 - match item.op with - | .leaf shard => - let originalShard := (view.shardIds[shard]?).getD shard - let some wrapper := proofsByShard.get? shard | do - IO.eprintln s!"internal: no proof for shard {originalShard}" - return 1 - let some preparedShard := prepared[shard]? | do - IO.eprintln s!"internal: no statement for shard {originalShard}" - return 1 - let claimBytes := Ix.Claim.ser preparedShard.claim - let verifyInput := IxVM.ClaimHarness.packedDigestKey - (Address.blake3 claimBytes) - let innerClaim := Aiur.buildClaim verifyIdx verifyInput #[] - let innerProof := Aiur.Proof.ofBytes wrapper.proof - match ixvmSystem.verify innerClaim innerProof with - | .error e => - IO.eprintln s!"shard {originalShard} proof fails native verification: {e}" - return 1 - | .ok () => pure () - let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] - let cached? ← match cacheDir? with - | none => pure none - | some dir => loadCachedAggregateProof dir slotIdx spec recursionSystem - let (proof, proofAddress?) ← match cached? with - | some cached => pure (cached.proof, some cached.address) - | none => - let pubInput := MultiStark.verifierPubInput ixvmVk innerClaimsBytes - IO.println s!"[aggregate] lifting shard {originalShard} into slot {slotIdx}" - (← IO.getStdout).flush - let (outerClaim, proof) := recursionSystem.proveMultiStark liftIdx pubInput - wrapper.proof ixvmVk innerClaimsBytes - if outerClaim != spec.outerClaim then - IO.eprintln s!"internal: lift slot {slotIdx} produced an unexpected outer claim" - return 1 - let proofAddress? ← match cacheDir? with - | none => pure none - | some dir => persistAggregateCacheProof dir slotIdx spec proof - pure (proof, proofAddress?) - slots := slots.push { - statement := spec.statement - subjectCount := spec.subjectCount - outerClaim := spec.outerClaim - proof - proofAddress? - openPreimages := #[innerClaimsBytes, claimBytes] - } - | .join leftIdx rightIdx => - let some left := slots[leftIdx]? | do - IO.eprintln s!"invalid aggregate plan: missing left slot {leftIdx}" - return 1 - let some right := slots[rightIdx]? | do - IO.eprintln s!"invalid aggregate plan: missing right slot {rightIdx}" - return 1 - let output := spec.statement - let outputClaimBytes := Ix.Claim.ser output.claim - let cached? ← match cacheDir? with - | none => pure none - | some dir => loadCachedAggregateProof dir slotIdx spec recursionSystem - let (proof, proofAddress?) ← match cached? with - | some cached => pure (cached.proof, some cached.address) - | none => - let pubInput := MultiStark.joinPubInput allowed outputClaimBytes - let leftClaimsBytes := MultiStark.serializeClaims #[left.outerClaim] - let rightClaimsBytes := MultiStark.serializeClaims #[right.outerClaim] - let preimagesBlob := MultiStark.joinPreimagesBlob - (left.openPreimages ++ right.openPreimages) - let trees := if item.structural then - MultiStark.CheckEnvTrees.structuralAdviceTrees - left.statement right.statement output - else - MultiStark.CheckEnvTrees.adviceTrees - left.statement right.statement output - let treesBlob := MultiStark.joinTreesBlob trees - let pathsBlob := if item.structural then - MultiStark.joinPathsBlob - (MultiStark.CheckEnvTrees.structuralPathAdvice - left.statement right.statement output) - else - MultiStark.joinPathsBlob #[] - let joinFunIdx := if item.structural then structuralJoinIdx else joinIdx - let mode := if item.structural then "structural" else "flat" - IO.println s!"[aggregate] {mode}-joining slots {leftIdx}, {rightIdx} into {slotIdx}" - (← IO.getStdout).flush - let result := recursionSystem.proveMultiStarkJoin joinFunIdx pubInput - left.proof.toBytes right.proof.toBytes recursionVk - leftClaimsBytes rightClaimsBytes outputClaimBytes allowed - preimagesBlob treesBlob pathsBlob - let (outerClaim, proof) ← match result with - | .error e => IO.eprintln s!"join slot {slotIdx}: {e}"; return 1 - | .ok result => pure result - if outerClaim != spec.outerClaim then - IO.eprintln s!"internal: join slot {slotIdx} produced an unexpected outer claim" - return 1 - let proofAddress? ← match cacheDir? with - | none => pure none - | some dir => persistAggregateCacheProof dir slotIdx spec proof - pure (proof, proofAddress?) - slots := slots.push { - statement := output - subjectCount := spec.subjectCount - outerClaim := spec.outerClaim - proof - proofAddress? - openPreimages := #[outputClaimBytes] - } + let proveContext : AggregateProveContext := { + plan, specs, prepared, proofsByShard, shardIds := view.shardIds + ixvmSystem, recursionSystem, ixvmVk, recursionVk, allowed + verifyIdx, liftIdx, joinIdx, structuralJoinIdx, 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" @@ -577,6 +890,8 @@ def aggregateCmd : Cli.Cmd := `[Cli| "ixes" : String; "Path to the shard manifest; its bisection tree determines join order." "plan-only"; "Validate coverage and print the lift/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)." ARGS: diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index ed472926b..a40acd77d 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -779,6 +779,74 @@ def joinSmokeSuite : IO UInt32 := do 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 @@ -853,6 +921,92 @@ def joinSmokeSuite : IO UInt32 := do | _, _ => 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, @@ -919,6 +1073,24 @@ def joinSmokeSuite : IO UInt32 := do 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" From f43447c53d4d512f0e13ad3fdc617b64b45f0018 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Fri, 28 Aug 2026 18:37:42 +0000 Subject: [PATCH 13/44] aiur: scale static shard seeds by block profile --- Ix/Cli/BenchCmd.lean | 16 ++--- Ix/Cli/ShardCmd.lean | 75 +++++++++------------ Ix/KernelCheck.lean | 14 ++-- crates/ffi/src/kernel.rs | 34 ++++++++-- crates/kernel/src/shard.rs | 132 ++++++++++++++++++++++++++++++++++--- 5 files changed, 198 insertions(+), 73 deletions(-) diff --git a/Ix/Cli/BenchCmd.lean b/Ix/Cli/BenchCmd.lean index 9d74c5639..ecc699f74 100644 --- a/Ix/Cli/BenchCmd.lean +++ b/Ix/Cli/BenchCmd.lean @@ -286,7 +286,7 @@ def backendSpecs : List BackendSpec := [ -- waves are audit extras outside it. ISLB only for now (~10 min/run); -- add "FLT" / "Mathlib" to `envs` for the env-scale tiers when their -- per-push cost is warranted. `shards` counts leaves — deterministic - -- per (env bytes, budget), rising only when the seed under-counts → + -- per (env static block profile, budget), rising only when the seed under-counts → -- upper-only pin, re-pin on a justified seed or split change. { name := "aiur-sharded-env", defaultMode := "execute", inputs := .perEnv, envs := some ["ISLB"], @@ -749,13 +749,13 @@ is not a benchmark run" if exit != 0 && exit != exitRejected then IO.eprintln s!"[bench] per-constant checks failed (exit {exit})" | "aiur-sharded-env" => - -- Whole-env sharded Aiur execution: shard the env for the runner's - -- RAM (naive `--max-ram 100` sizing → ~3.5 GB execution RSS per - -- shard), then ONE gated full-width rayon batch over the manifest — - -- the RamGate bounds peak RSS, so no `--jobs` is passed. The check - -- writes the env-keyed row itself (`--json`): check-time, - -- throughput, peak-rss, constants, shards. The shard step is - -- deterministic setup, not part of the measured window. + -- Whole-env sharded Aiur execution: seed the env for the runner's RAM + -- from its static block-shape score (`--max-ram 100`), then ONE gated + -- full-width rayon batch over the manifest — the RamGate bounds peak + -- RSS, so no `--jobs` is passed. The check writes the env-keyed row + -- itself (`--json`): check-time, throughput, peak-rss, constants, + -- shards. The shard step is deterministic setup, not part of the + -- measured window. let ixe ← ensureIxe repo info ((p.flag? "ixe").map (·.as! String)) let ix ← resolveBin repo "ix" let manifest := s!"{env}-exec.ixes" diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean index 148b8b6a7..3e5a4b294 100644 --- a/Ix/Cli/ShardCmd.lean +++ b/Ix/Cli/ShardCmd.lean @@ -8,10 +8,12 @@ static walk-edge nets (the relation that generates each shard's thin frontier, i.e. its real ingress), then a global rebalance post-pass toward equal predicted Aiur FFT cost (fitted model — constants and - provenance in `ix_kernel::shard::STATIC_OWNED_PER_BYTE`). Requires - `--shards N`. Measured against the profiled strategy on the 8-shard - Init / 24-shard Std harnesses: mean shard FFT −30%, max shard −44/−51%, - stddev 17.7%→7.1% / 30.6%→8.9%. + provenance in `ix_kernel::shard::STATIC_OWNED_PER_BYTE`). `--shards N` + fixes the count; `--max-ram G` seeds it from the same static block-shape + score, mildly superlinear in both library scale and inverse RAM budget. + Measured against the profiled strategy on the 8-shard Init / 24-shard Std + harnesses: mean shard FFT −30%, max shard −44/−51%, stddev 17.7%→7.1% / + 30.6%→8.9%. - **Profiled (`--profile `)**: the original pipeline over an `ix profile` run, unchanged. Modes (precedence in `runShardCmd`): default / `--max-ram G` / `--max-cycles C` **bin-pack to a per-shard @@ -33,7 +35,6 @@ module public import Cli public import Ix.Common public import Ix.KernelCheck -public import Ix.Cli.CheckLeanCmd public import Ix.Cli.ConstsFile public section @@ -145,49 +146,33 @@ def runShardCmd (p : Cli.Parsed) : IO UInt32 := do | none => -- STATIC strategy (no out-of-circuit profiling): byte-balanced min-cut -- over the env's walk-edge nets + predicted-FFT rebalance post-pass. - -- Shard count comes from `--shards N`, or from the SEED heuristic - -- under `--max-ram G` — a bracketed order-of-magnitude count, never - -- a sizer: boundaries and budget fitting are measured where - -- execution happens anyway (the prove gate splits over-budget - -- shards inline and the corrected manifest remembers the leaves). + -- `--shards N` fixes the count. Under `--max-ram G`, Rust chooses a + -- seed only after building the static block profile: the fitted owned + -- score sees both bytes and their per-block shape, unlike `.ixe` file + -- size. Boundaries and budget fitting are still measured where execution + -- happens anyway (the prove gate splits over-budget shards inline and the + -- corrected manifest remembers the leaves). if maxCycles.isSome then p.printError "error: --max-cycles requires --profile (its budget \ model is calibrated on profiled op counters)" return 1 - let n ← match shardsFlag, maxRam with - | some n, _ => pure n - | none, some gib => - if gib == 0 then - p.printError "error: --max-ram must be positive"; return 1 - -- SEED heuristic, not a sizer, calibrated to MATHLIB-CLASS - -- amplification because that is the common shape of real Lean - -- libraries (Mathlib and everything importing it), not an - -- outlier. Measured peak-per-env-byte at fitting granularity: - -- Mathlib ~20,200x at 132 shards and rising with count (a - -- 17,000x midpoint seed put 129/132 shards over a 400 GiB - -- budget, costing a full extra execution wave, 2026-08-29); - -- FLT ~19,600x at 241; init only ~12,500-14,000x. Targeting - -- 2/3 of the budget with the 20,000x class constant lands - -- Mathlib-class envs at ~70% fill with single-digit splits - -- (measured: FLT 241 shards, 6 over; Mathlib 233, mean 285). - -- Low-amplification small envs over-shard instead (init: ~50% - -- first-run fill) — the cheap direction, reclaimed by the - -- printed consolidation count; gated execution corrects every - -- boundary either way. - let seedAmp := 20000 - let envBytes := (← System.FilePath.metadata envPath).byteSize.toNat - let targetBytes := gib * gibBytes * 2 / 3 - let n := max 1 ((envBytes * seedAmp + targetBytes - 1) / targetBytes) - IO.println s!"[shard] seed count: {envBytes} env bytes × \ - {seedAmp} / ({gib} GiB × 2/3) → {n} shard(s) (heuristic; gated \ - execution corrects every boundary)" - pure n - | none, none => - p.printError "error: the static strategy (no --profile) requires \ - --shards N or --max-ram G" - return 1 - IO.println s!"Sharding {envPath} into {n} shards (static strategy, balance ±{balancePct}%)" - rsShardEnvStaticFFI envPath (toString n) (toString balancePct) outPath + match shardsFlag, maxRam with + | some n, _ => + if n == 0 then + p.printError "error: --shards must be positive"; return 1 + IO.println s!"Sharding {envPath} into {n} shards \ + (static strategy, balance ±{balancePct}%)" + rsShardEnvStaticFFI envPath (toString n) "0" (toString balancePct) outPath + | none, some gib => + if gib == 0 then + p.printError "error: --max-ram must be positive"; return 1 + IO.println s!"Sharding {envPath} for a {gib} GiB prover budget \ + (static block-shape seed, balance ±{balancePct}%)" + rsShardEnvStaticFFI envPath "0" (toString gib) (toString balancePct) outPath + | none, none => + p.printError "error: the static strategy (no --profile) requires \ + --shards N or --max-ram G" + return 1 | some espPath => -- Profiled strategy, unchanged: partition the `.ixprof`. -- Precedence: explicit --shards (fixed count) > explicit --max-cycles/--max-ram @@ -219,7 +204,7 @@ def shardCmd : Cli.Cmd := `[Cli| profile : String; "Path to a `.ixprof` from `ix profile`. When given, use the profiled strategy (cap budgeting / balanced min-cut over measured costs); when absent, the static strategy partitions the `.ixe` directly." shards : Nat; "Fixed number of shards N (static strategy; overrides --max-ram sizing and the profiled default budget sizing)" "max-cycles" : Nat; "Per-shard guest-cycle budget (profiled strategy only)" - "max-ram" : Nat; "Per-shard prover-RAM budget, GiB. Static strategy: SEED heuristic for the shard count — Mathlib-class amplification (~20,000× env bytes, the common shape of real Lean libraries) against 2/3 of the budget, landing that class at ~70% fill with single-digit splits; small low-amplification envs over-shard instead (the cheap, reclaimable direction). The prove gate corrects every boundary by execution. Profiled strategy: budget from measured op counters (default: detected system RAM)." + "max-ram" : Nat; "Per-shard prover-RAM budget, GiB. Static strategy: seed the shard count from the `.ixe` block-shape score (serialized block size + a superlinear large-body term), with fitted scale and budget exponents anchored at Mathlib; the execution gate measures and corrects every boundary. Profiled strategy: budget from measured op counters (default: detected system RAM)." balance : Nat; "Per-bisection balance tolerance, percent (default 5)" parallelism : Nat; "Provers assumed for the prove-time estimate (profiled strategy only; default 1 = sequential)" out : String; "Output .ixes manifest path (default: env base name + `.ixes`, e.g. init.ixe → init.ixes)" diff --git a/Ix/KernelCheck.lean b/Ix/KernelCheck.lean index d403997a5..3c72b13e0 100644 --- a/Ix/KernelCheck.lean +++ b/Ix/KernelCheck.lean @@ -194,15 +194,17 @@ opaque rsEnvExtractFFI : @& Bool → -- quiet IO Unit -/-- FFI: partition a `.ixe` into `numShards` shards with the STATIC - strategy (no out-of-circuit profiling): byte-balanced min-cut over the - static walk-edge nets + a predicted-FFT-cost rebalance post-pass - (`ix_kernel::shard::shard_static`; model constants documented there). - Writes a `.ixes` manifest; prints the report to stderr. -/ +/-- FFI: partition a `.ixe` with the STATIC strategy (no out-of-circuit + profiling): byte-balanced min-cut over the static walk-edge nets + a + predicted-FFT-cost rebalance post-pass (`ix_kernel::shard::shard_static`; + model constants documented there). A nonzero `numShards` fixes the count; + otherwise `ramGib` selects the static block-shape seed after the `.ixe` has + been profiled. Writes a `.ixes` manifest; prints the report to stderr. -/ @[extern "rs_shard_env_static"] opaque rsShardEnvStaticFFI : @& String → -- .ixe path - @& String → -- num_shards (N) + @& String → -- num_shards (N; "0" = score seed) + @& String → -- max RAM GiB (used when N = 0) @& String → -- balance percent @& String → -- .ixes output path ("" = skip) IO Unit diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index 2cb64cc98..02a5d7c24 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -2331,21 +2331,30 @@ fn static_block_profile(env: &IxonEnv) -> BlockProfile { builder.finish() } -/// FFI: partition a `.ixe` into `num_shards` shards with the STATIC -/// strategy — no out-of-circuit profiling run. Builds the static block -/// profile ([`static_block_profile`]), byte-balanced min-cut over the -/// walk-edge nets, then the predicted-cost rebalance post-pass +/// FFI: partition a `.ixe` with the STATIC strategy — no out-of-circuit +/// profiling run. An explicit nonzero `num_shards` fixes the count. Otherwise, +/// `ram_gib` seeds it from the static block-shape score after the profile is +/// loaded ([`ix_kernel::shard::static_seed_shards`]). Builds the static block +/// profile ([`static_block_profile`]), byte-balanced min-cut over the walk-edge +/// nets, then the predicted-cost rebalance post-pass /// (`ix_kernel::shard::shard_static`). Writes a `.ixes` manifest. #[allow(clippy::cast_precision_loss)] // balance_pct is a small percentage #[unsafe(no_mangle)] pub extern "C" fn rs_shard_env_static( env_path: LeanString>, num_shards: LeanString>, + ram_gib: LeanString>, balance_pct: LeanString>, out_path: LeanString>, ) -> LeanIOResult { let path = env_path.to_string(); - let num_shards = num_shards.to_string().parse::().unwrap_or(1); + let requested_shards = num_shards.to_string().parse::().unwrap_or(0); + let ram_gib = ram_gib.to_string().parse::().unwrap_or(0); + if requested_shards == 0 && ram_gib == 0 { + return LeanIOResult::error_string( + "rs_shard_env_static: pass a positive shard count or RAM budget", + ); + } let balance = (balance_pct.to_string().parse::().unwrap_or(5) as f64) / 100.0; let out = out_path.to_string(); @@ -2369,6 +2378,21 @@ pub extern "C" fn rs_shard_env_static( profile.num_blocks(), profile.num_edges() ); + let num_shards = if requested_shards > 0 { + requested_shards + } else { + let score = ix_kernel::shard::static_env_score(&profile); + let n = ix_kernel::shard::static_seed_shards(&profile, ram_gib); + eprintln!( + "[shard] static seed: score={score:.3e}; round({} x (score/{:.3e})^{:.2} x ({}/{ram_gib})^{:.2}) -> {n} shard(s) (heuristic; gated execution corrects every boundary)", + ix_kernel::shard::STATIC_SEED_REFERENCE_SHARDS, + ix_kernel::shard::STATIC_SEED_REFERENCE_SCORE, + ix_kernel::shard::STATIC_SEED_SCORE_EXPONENT, + ix_kernel::shard::STATIC_SEED_REFERENCE_RAM_GIB, + ix_kernel::shard::STATIC_SEED_BUDGET_EXPONENT, + ); + n + }; match ix_kernel::shard::shard_static(&profile, num_shards, balance, out_opt) { Ok(report) => { eprintln!("[rs_shard_static]\n{report}"); diff --git a/crates/kernel/src/shard.rs b/crates/kernel/src/shard.rs index b77283156..a9e3eb70d 100644 --- a/crates/kernel/src/shard.rs +++ b/crates/kernel/src/shard.rs @@ -2,15 +2,16 @@ //! cross-shard delta-unfold ingress (see `plans/sharding.md`). Two driving //! modes share the same min-cut machinery: //! -//! - **Fixed count** ([`Hypergraph::partition`], the `--shards N` CLI path): -//! recursive *balanced* min-cut bisection into exactly `N` shards — even -//! per-shard work, the bisection tree doubling as the aggregation tree. -//! - **Cap / packing** ([`partition_for_cycle_cap`], the default and -//! `--max-cycles`/`--max-ram` paths): **bin-pack to the cap** — the fewest -//! shards that each stay under a per-shard cycle (hence prover-RAM) budget, -//! each filled as full as the dependency structure allows. This does *not* -//! balance: uniformity over-shards (every shard left partly empty), whereas -//! packing hits `≈⌈total/cap⌉` shards. It still uses a fine min-cut +//! - **Fixed count** ([`Hypergraph::partition`], explicit `--shards N` and the +//! static strategy's `--max-ram` score seed): recursive *balanced* min-cut +//! bisection into exactly `N` shards — even per-shard work, the bisection tree +//! doubling as the aggregation tree. +//! - **Cap / packing** ([`partition_for_cycle_cap`], the profiled strategy's +//! default and `--max-cycles`/`--max-ram` paths): **bin-pack to the cap** — the +//! fewest shards that each stay under a per-shard cycle (hence prover-RAM) +//! budget, each filled as full as the dependency structure allows. This does +//! *not* balance: uniformity over-shards (every shard left partly empty), +//! whereas packing hits `≈⌈total/cap⌉` shards. It still uses a fine min-cut //! pre-partition for a **cut-coherent order** so dependency overlap packs into //! the same shard (overlap paid once, not re-ingressed per shard). //! @@ -1617,12 +1618,72 @@ pub const STATIC_OWNED_SUPERLINEAR: f64 = 681.08; /// See [`STATIC_OWNED_PER_BYTE`]. pub const STATIC_FRONTIER_PER_BYTE: f64 = 38_000.0; +/// Reference point for the profile-free shard-count seed: Mathlib's static +/// owned-side score under this model. At a 400 GiB prover budget, 233 seed +/// shards gave the established Mathlib-class behavior (a small number of +/// heavy-tail splits, corrected by the execution gate). +pub const STATIC_SEED_REFERENCE_SCORE: f64 = 1.254e14; +/// Mathlib seed count at [`STATIC_SEED_REFERENCE_RAM_GIB`]. +pub const STATIC_SEED_REFERENCE_SHARDS: f64 = 233.0; +/// Prover-RAM budget of the reference calibration. +pub const STATIC_SEED_REFERENCE_RAM_GIB: f64 = 400.0; +/// Mild superlinear scale correction over the static owned-side score. +/// +/// A linear score model still over-counted the small environments: cross-shard +/// duplication and the heavy-tail risk both grow with library scale. The 1.10 +/// exponent preserves the Mathlib reference while fitting the measured knees +/// at Init (8 shards) and ISLB (23) at the 400 GiB reference budget. +pub const STATIC_SEED_SCORE_EXPONENT: f64 = 1.10; +/// Superlinear correction when scaling the seed away from 400 GiB. +/// +/// Fitted on the 2026-08-28 100 GiB calibration: linear scaling caused broad +/// correction (Init 32→48 leaves; ISLB 93→123), while 1.20 seeded Init at 43 +/// (42 measured clean) and ISLB at 122 (four initial misses, 128 leaves). +/// Out-of-sample Batteries seeded 74 with one initial miss and 79 leaves. The +/// discarded 1.36 candidate over-seeded ISLB at 152→156. Unlike the score +/// exponent, this changes no reference-budget prediction. +pub const STATIC_SEED_BUDGET_EXPONENT: f64 = 1.20; + /// Predicted owned-side cost of one block under the static model. fn static_owned_weight(size: u32) -> f64 { let s = f64::from(size); STATIC_OWNED_PER_BYTE * s + STATIC_OWNED_SUPERLINEAR * s * s.sqrt() } +/// Whole-environment owned-side score used only to seed a shard count. +/// +/// There is no frontier when the environment is viewed as one set, so this is +/// just the sum of [`static_owned_weight`] over blocks. Unlike raw `.ixe` file +/// bytes, it sees how bytes are packaged: the superlinear term distinguishes a +/// large reduction-heavy proof body from the same bytes spread over many small +/// declarations. The actual partition still includes frontier cost and is +/// always checked by the execution-time prover-RAM gate. +pub fn static_env_score(profile: &BlockProfile) -> f64 { + profile.blocks().iter().map(|b| static_owned_weight(b.serialized_size)).sum() +} + +/// Score/budget model for the profile-free shard-count seed. +/// +/// This deliberately rounds to the nearest shard instead of always rounding +/// upward: it is a seed, not a safety boundary, and the prove/check execution +/// gate measures and splits every over-budget shard before a STARK starts. +/// Avoiding an unconditional upward bias matters most for small environments. +fn static_seed_shards_for_score(score: f64, ram_gib: u64) -> usize { + let budget = ram_gib.max(1) as f64; + let scaled = STATIC_SEED_REFERENCE_SHARDS + * (score / STATIC_SEED_REFERENCE_SCORE).powf(STATIC_SEED_SCORE_EXPONENT) + * (STATIC_SEED_REFERENCE_RAM_GIB / budget).powf(STATIC_SEED_BUDGET_EXPONENT); + scaled.round().max(1.0) as usize +} + +/// Suggested static seed count for `profile` at a per-shard prover-RAM budget. +/// The result is capped at one shard per atomic block; finer partitioning could +/// only create empty shards and cannot make an oversized block splittable. +pub fn static_seed_shards(profile: &BlockProfile, ram_gib: u64) -> usize { + static_seed_shards_for_score(static_env_score(profile), ram_gib) + .min(profile.num_blocks().max(1)) +} + /// Greedy global rebalance toward equal predicted per-shard cost under the /// static model. Repeatedly moves the best block from the most expensive /// shard to the cheapest until the hot/cold gap is within 1% of the mean @@ -2543,6 +2604,59 @@ mod tests { ); } + #[test] + fn static_seed_model_scales_by_score_and_budget() { + // 400 GiB calibration points from the 2026-08-28 sweep. Init and ISLB + // are the small/mid-size knees; Mathlib is the normalization point. FLT + // records the large-env extrapolation, not an optimum (its old corrected + // leaf count depended on the previous seed). These are scores, not raw + // env bytes. + assert_eq!(static_seed_shards_for_score(6.010e12, 400), 8); // Init + assert_eq!(static_seed_shards_for_score(1.536e13, 400), 23); // ISLB + assert_eq!( + static_seed_shards_for_score(STATIC_SEED_REFERENCE_SCORE, 400), + 233 + ); + assert_eq!(static_seed_shards_for_score(1.316e14, 400), 246); // FLT + + // The 100 GiB calibration keeps broad split correction out of Init and + // ISLB without the 1.36 experiment's over-sharding. + assert_eq!(static_seed_shards_for_score(6.010e12, 100), 43); // Init + assert_eq!(static_seed_shards_for_score(1.536e13, 100), 122); // ISLB + assert_eq!( + static_seed_shards_for_score(STATIC_SEED_REFERENCE_SCORE, 100), + 1230 + ); + + // An empty or vanishingly small score still produces a usable one-shard + // seed. + assert_eq!(static_seed_shards_for_score(0.0, 400), 1); + } + + #[test] + fn static_env_score_distinguishes_block_shape() { + let mut concentrated = ProfileBuilder::new(); + concentrated.block(addr(1), 0, 4000, 1, OpCounts::default()); + + let mut spread = ProfileBuilder::new(); + for i in 1..=4u8 { + spread.block(addr(i), 0, 1000, 1, OpCounts::default()); + } + + assert!(static_env_score(&concentrated.finish()) > static_env_score(&spread.finish())); + } + + #[test] + fn static_seed_count_never_exceeds_atomic_blocks() { + let mut b = ProfileBuilder::new(); + for i in 1..=6u8 { + // Force the uncapped estimate far above six shards. + b.block(addr(i), 0, u32::MAX, 1, OpCounts::default()); + } + let p = b.finish(); + assert_eq!(static_seed_shards(&p, 1), p.num_blocks()); + } + #[test] fn objective_matches_manifest_cross_ingress() { let p = two_clusters(); From 80854d188857b74dd84d0eb50467ec607821c15f Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Fri, 28 Aug 2026 18:53:36 +0000 Subject: [PATCH 14/44] bench(aggregate): add tiny Init pair end-to-end benchmark --- Benchmarks/AggregatePair.lean | 696 ++++++++++++++++++++++++++++++++++ lakefile.lean | 4 + 2 files changed, 700 insertions(+) create mode 100644 Benchmarks/AggregatePair.lean diff --git a/Benchmarks/AggregatePair.lean b/Benchmarks/AggregatePair.lean new file mode 100644 index 000000000..81e451c9d --- /dev/null +++ b/Benchmarks/AggregatePair.lean @@ -0,0 +1,696 @@ +import Ix.Cli.AggregateCmd +import Ix.Cli.NameResolve +import Ix.TracingTexray +import Ix.Benchmark.Bench + +/-! +# Two-shard end-to-end production aggregation benchmark + +This is deliberately a benchmark executable rather than a production CLI +mode. It can select two shards from a validated `.ixes` manifest and benchmark +the complete proof path: + +``` +shard A -> IxVM proof A -> recursive lift A ---+ + +-> structural/flat join -> verify +shard B -> IxVM proof B -> recursive lift B ---+ +``` + +Unlike `ix aggregate`, the result is allowed to retain assumptions and need +not cover the whole environment. It therefore cannot be mistaken for a closed +full-environment aggregate. + +With no arguments it reads `init.ixe` and treats the `False` and `True` block +groups as two conditional micro-shards. They exercise the real Init environment +and production proof stack without inheriting the memory footprint of a full +RAM-planned shard. `--ixes` switches to a complete manifest and automatically +chooses its smallest direct sibling pair. Supplying `--shard-a` and `--shard-b` +instead selects any two nonempty shards from that manifest; they need not be +siblings: + +``` +lake exe bench-aggregate-pair -- \ + --ixe /path/init.ixe --name-a False --name-b True \ + --json /tmp/init-pair.json --texray + +lake exe bench-aggregate-pair -- \ + --ixe /path/init.ixe --ixes /path/init.ixes \ + --shard-a 3 --shard-b 17 --json /tmp/init-real-pair.json +``` + +`--proof-a` and `--proof-b` may be supplied together to reuse persisted base +proofs. They are an explicit warm-start mode; the default always measures base +proving as well as recursive aggregation. + +Every stage is the real production proof call, with no execution-only preflight +or memory gate. Like `bench-typecheck --recursive`, the default benchmark +profile uses 50 FRI queries and zero query PoW for both base and recursive +proofs; `--queries` can override the count. Timings and measured peak RSS are +recorded after the fact. +-/ + +open Lean (Json) + +namespace Benchmarks.AggregatePair + +open Ix +open Ix.Cli.AggregateCmd + +abbrev AggregationTree := Ix.Cli.CheckCmd.AggregationTree +abbrev FoldOp := Ix.Cli.CheckCmd.AggregationTree.FoldOp + +/-- Keep this in lockstep with `Benchmarks.Typecheck.recursiveFriParameters`. +The benchmark measures the full recursive architecture under the repository's +established tractable recursion profile, not the 100-query production policy. -/ +def benchmarkFriParameters (queries : Nat) : Aiur.FriParameters := { + logFinalPolyLen := 0 + maxLogArity := 1 + numQueries := queries + commitProofOfWorkBits := 0 + queryProofOfWorkBits := 0 +} + +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 stageJson (fields : List (String × Json)) : Json := + Json.mkObj (("status", Json.str "ok") :: fields) + +def errorJson (message : String) : Json := + Json.mkObj [("status", Json.str "error"), ("message", Json.str message)] + +def writeReport (path? : Option String) (metadata : List (String × Json)) + (status : String) (stages : Array (String × Json)) : IO Unit := do + if let some path := path? then + let report := Json.mkObj (metadata ++ + [("status", Json.str status), ("stages", Json.mkObj stages.toList)]) + IO.FS.writeFile path (report.pretty ++ "\n") + +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 } + +def blockOfAddress (env : Ixon.Env) (address : Address) : Except String Address := do + let some constant := env.getConst? address + | throw s!"constant {address} is absent or malformed" + pure <| match constant.info with + | .iPrj projection => projection.block + | .cPrj projection => projection.block + | .rPrj projection => projection.block + | .dPrj projection => projection.block + | _ => address + +def namedMicroShard (env : Ixon.Env) (name : String) : + Except String (Array Address) := do + let some address := Ix.Cli.NameResolve.resolveIxeAddr env name + | throw s!"Init micro-shard name not found: {name}" + pure #[← blockOfAddress env address] + +partial def siblingLeafPairs (tree : AggregationTree) : Array (Nat × Nat) := + match tree with + | .leaf _ => #[] + | .node left right => + let here := match left, right with + | .leaf l, .leaf r => #[(l, r)] + | _, _ => #[] + here ++ siblingLeafPairs left ++ siblingLeafPairs right + +/-- The smallest direct sibling pair by combined subject count. The manifest +tree and count array have already passed coverage/pruning validation. -/ +def smallestSiblingPair? (tree : AggregationTree) (counts : Array Nat) : + Option (Nat × Nat) := + (siblingLeafPairs tree).foldl (init := none) fun best pair => + match best with + | none => some pair + | some current => + let pairCount := counts[pair.1]! + counts[pair.2]! + let currentCount := counts[current.1]! + counts[current.2]! + if pairCount < currentCount then some pair else some current + +def loadProofWrapper (label proofAddress : String) : IO (Except String Ixon.Proof) := do + let some address := Address.fromString proofAddress + | return .error s!"{label}: expected a 64-character store address" + try + match Ixon.Proof.de (← StoreIO.toIO (Store.read address)) with + | .error error => pure (.error s!"{label}: wrapper decode failed: {error}") + | .ok wrapper => pure (.ok wrapper) + catch error => + pure (.error s!"{label}: store read failed: {error}") + +structure BenchSlot where + slot : AggregateSlot + proveSeconds : Float + +structure BaseProofBench where + wrapper : Ixon.Proof + proveSeconds : Float + +/-- Generate one ordinary shard proof through the same native EnvHandle path as +`ix prove --ixe E --ixes M --shard K`, but retain it in memory for the lift. -/ +def runBaseProof (label : String) (envHandle : Aiur.EnvHandle) + (owned : Array Address) (expectedClaim : Ix.Claim) + (ixvmSystem : Aiur.AiurSystem) (verifyIdx : Aiur.Bytecode.FunIdx) + (record : String → Json → IO Unit) : IO (Except String BaseProofBench) := do + let ownedBlob := owned.foldl (fun bytes address => bytes ++ address.hash) + ByteArray.empty + IO.println s!"[pair-bench] proving {label}" + (← IO.getStdout).flush + TracingTexray.resetPeakTreeRss + let (proved, proveSeconds) ← timed fun _ => + ixvmSystem.shardProveWithEnv verifyIdx envHandle ownedBlob + let provePeak ← TracingTexray.peakTreeRssBytes + let (claimBytes, proof) ← match proved with + | .error error => + record s!"{label}-prove" (errorJson error) + return .error s!"{label}: shardProveWithEnv failed: {error}" + | .ok (claimBytes, proof, _) => pure (claimBytes, proof) + let claim ← match Ixon.runGet Ix.Claim.get claimBytes with + | .error error => + record s!"{label}-prove" (errorJson s!"claim decode failed: {error}") + return .error s!"{label}: claim decode failed: {error}" + | .ok claim => pure claim + if claim != expectedClaim then + let error := "native shard prover returned a different CheckEnv claim" + record s!"{label}-prove" (errorJson error) + return .error s!"{label}: {error}" + let proofBytes := proof.toBytes + record s!"{label}-prove" (stageJson + [("seconds", jsonRound 6 proveSeconds), + ("peak-rss-bytes", Lean.toJson provePeak), + ("proof-bytes", Lean.toJson proofBytes.size), + ("source", Json.str "generated")]) + pure (.ok { + wrapper := { claim, proof := proofBytes } + proveSeconds + }) + +def reuseBaseProof (label address : String) (expectedClaim : Ix.Claim) + (record : String → Json → IO Unit) : IO (Except String BaseProofBench) := do + let wrapper ← match ← loadProofWrapper label address with + | .error error => return .error error + | .ok wrapper => pure wrapper + if wrapper.claim != expectedClaim then + return .error s!"{label}: persisted wrapper claim does not match the selected shard" + record s!"{label}-prove" (stageJson + [("seconds", jsonRound 6 0), + ("peak-rss-bytes", Lean.toJson (0 : Nat)), + ("proof-bytes", Lean.toJson wrapper.proof.size), + ("source", Json.str "reused")]) + pure (.ok { wrapper, proveSeconds := 0 }) + +def runLift (label : String) (prepared : PreparedShard) (wrapper : Ixon.Proof) + (spec : AggregateSlotSpec) (ixvmSystem recursionSystem : Aiur.AiurSystem) + (verifyIdx liftIdx : Aiur.Bytecode.FunIdx) (ixvmVk : ByteArray) + (record : String → Json → IO Unit) : + IO (Except String BenchSlot) := do + if wrapper.claim != prepared.claim then + return .error s!"{label}: bundled CheckEnv claim does not match the selected shard" + let innerProof ← match Aiur.Proof.ofBytesChecked wrapper.proof with + | .error error => return .error s!"{label}: inner proof decode failed: {error}" + | .ok proof => pure proof + let claimBytes := Ix.Claim.ser prepared.claim + let verifyInput := IxVM.ClaimHarness.packedDigestKey (Address.blake3 claimBytes) + let innerClaim := Aiur.buildClaim verifyIdx verifyInput #[] + + TracingTexray.resetPeakTreeRss + let (innerVerified, innerVerifySeconds) ← timed fun _ => + ixvmSystem.verify innerClaim innerProof + let innerVerifyPeak ← TracingTexray.peakTreeRssBytes + match innerVerified with + | .error error => + record s!"{label}-inner-verify" (errorJson error) + return .error s!"{label}: inner proof verification failed: {error}" + | .ok () => + record s!"{label}-inner-verify" (stageJson + [("seconds", jsonRound 6 innerVerifySeconds), + ("peak-rss-bytes", Lean.toJson innerVerifyPeak), + ("proof-bytes", Lean.toJson wrapper.proof.size)]) + + let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] + let pubInput := MultiStark.verifierPubInput ixvmVk innerClaimsBytes + IO.println s!"[pair-bench] proving {label}" + (← IO.getStdout).flush + TracingTexray.resetPeakTreeRss + let ((outerClaim, proof), proveSeconds) ← timed fun _ => + recursionSystem.proveMultiStark liftIdx pubInput wrapper.proof ixvmVk innerClaimsBytes + let provePeak ← TracingTexray.peakTreeRssBytes + if outerClaim != spec.outerClaim then + let error := "produced an unexpected outer claim" + record s!"{label}-prove" (errorJson error) + return .error s!"{label}: {error}" + let proofBytes := proof.toBytes + record s!"{label}-prove" (stageJson + [("seconds", jsonRound 6 proveSeconds), + ("peak-rss-bytes", Lean.toJson provePeak), + ("proof-bytes", Lean.toJson proofBytes.size)]) + + TracingTexray.resetPeakTreeRss + let (verified, verifySeconds) ← timed fun _ => + recursionSystem.verify outerClaim proof + let verifyPeak ← TracingTexray.peakTreeRssBytes + match verified with + | .error error => + record s!"{label}-outer-verify" (errorJson error) + return .error s!"{label}: lift proof verification failed: {error}" + | .ok () => + record s!"{label}-outer-verify" (stageJson + [("seconds", jsonRound 6 verifySeconds), + ("peak-rss-bytes", Lean.toJson verifyPeak)]) + + pure (.ok { + slot := { + statement := spec.statement + subjectCount := spec.subjectCount + outerClaim + proof + proofAddress? := none + openPreimages := #[innerClaimsBytes, claimBytes] + } + proveSeconds + }) + +def runJoin (item : ScheduledFold) (left right : AggregateSlot) + (spec : AggregateSlotSpec) (recursionSystem : Aiur.AiurSystem) + (joinIdx structuralJoinIdx : Aiur.Bytecode.FunIdx) + (recursionVk allowed : ByteArray) + (record : String → Json → IO Unit) : IO (Except String BenchSlot) := do + let output := spec.statement + let outputClaimBytes := Ix.Claim.ser output.claim + let pubInput := MultiStark.joinPubInput allowed outputClaimBytes + let leftClaimsBytes := MultiStark.serializeClaims #[left.outerClaim] + let rightClaimsBytes := MultiStark.serializeClaims #[right.outerClaim] + let preimagesBlob := MultiStark.joinPreimagesBlob + (left.openPreimages ++ right.openPreimages) + let trees := if item.structural then + MultiStark.CheckEnvTrees.structuralAdviceTrees left.statement right.statement output + else + MultiStark.CheckEnvTrees.adviceTrees left.statement right.statement output + let treesBlob := MultiStark.joinTreesBlob trees + let pathsBlob := if item.structural then + MultiStark.joinPathsBlob + (MultiStark.CheckEnvTrees.structuralPathAdvice left.statement right.statement output) + else MultiStark.joinPathsBlob #[] + let joinFunIdx := if item.structural then structuralJoinIdx else joinIdx + let label := if item.structural then "structural-join" else "flat-join" + + IO.println s!"[pair-bench] proving {label}" + (← IO.getStdout).flush + TracingTexray.resetPeakTreeRss + let (proved, proveSeconds) ← timed fun _ => + recursionSystem.proveMultiStarkJoin joinFunIdx pubInput + left.proof.toBytes right.proof.toBytes recursionVk + leftClaimsBytes rightClaimsBytes outputClaimBytes allowed + preimagesBlob treesBlob pathsBlob + let provePeak ← TracingTexray.peakTreeRssBytes + let (outerClaim, proof) ← match proved with + | .error error => + record s!"{label}-prove" (errorJson error) + return .error s!"{label}: prove failed: {error}" + | .ok result => pure result + if outerClaim != spec.outerClaim then + let error := "produced an unexpected outer claim" + record s!"{label}-prove" (errorJson error) + return .error s!"{label}: {error}" + let proofBytes := proof.toBytes + record s!"{label}-prove" (stageJson + [("seconds", jsonRound 6 proveSeconds), + ("peak-rss-bytes", Lean.toJson provePeak), + ("proof-bytes", Lean.toJson proofBytes.size)]) + + TracingTexray.resetPeakTreeRss + let (verified, verifySeconds) ← timed fun _ => + recursionSystem.verify outerClaim proof + let verifyPeak ← TracingTexray.peakTreeRssBytes + match verified with + | .error error => + record s!"{label}-verify" (errorJson error) + return .error s!"{label}: proof verification failed: {error}" + | .ok () => + record s!"{label}-verify" (stageJson + [("seconds", jsonRound 6 verifySeconds), + ("peak-rss-bytes", Lean.toJson verifyPeak)]) + + pure (.ok { + slot := { + statement := output + subjectCount := spec.subjectCount + outerClaim + proof + proofAddress? := none + openPreimages := #[outputClaimBytes] + } + proveSeconds + }) + +structure PairSelection where + leftBlocks : Array Address + rightBlocks : Array Address + leftId : Nat + rightId : Nat + leftLabel : String + rightLabel : String + expectedLeftSubjects? : Option Nat := none + expectedRightSubjects? : Option Nat := none + source : String + manifestPath? : Option String := none + +def usage : String := + "usage: bench-aggregate-pair [--ixe E] [--name-a A --name-b B] " ++ + "[--ixes M --shard-a A --shard-b B] " ++ + "[--proof-a ADDR --proof-b ADDR] " ++ + "[--queries N] [--structural-above N] [--json PATH] " ++ + "[--plan-only] [--texray]" + +def main (args : List String) : IO UInt32 := do + let ixePath := (argStr args "--ixe").getD "init.ixe" + let manifestPath? := argStr args "--ixes" + let requestedA? := argNat? args "--shard-a" + let requestedB? := argNat? args "--shard-b" + if requestedA?.isSome != requestedB?.isSome then + IO.eprintln "error: --shard-a and --shard-b must be supplied together" + IO.eprintln usage + return 2 + if let some requestedA := requestedA? then + if requestedB? == some requestedA then + IO.eprintln "error: --shard-a and --shard-b must differ" + return 2 + if manifestPath?.isNone && requestedA?.isSome then + IO.eprintln "error: --shard-a/--shard-b require --ixes" + return 2 + if manifestPath?.isSome && + ((argStr args "--name-a").isSome || (argStr args "--name-b").isSome) then + IO.eprintln "error: --name-a/--name-b select micro-shards and cannot accompany --ixes" + return 2 + let proofAHex? := argStr args "--proof-a" + let proofBHex? := argStr args "--proof-b" + if proofAHex?.isSome != proofBHex?.isSome then + IO.eprintln "error: --proof-a and --proof-b must be supplied together" + IO.eprintln usage + return 2 + let structuralAbove := (argNat? args "--structural-above").getD defaultStructuralAbove + let queries := (argNat? args "--queries").getD 50 + if queries == 0 then + IO.eprintln "error: --queries must be positive" + return 2 + let jsonPath? := argStr args "--json" + + TracingTexray.startSampler 25 + if hasFlag args "--texray" then TracingTexray.init {} + + let env ← match Ixon.deEnvAnon (← IO.FS.readBinFile ixePath) with + | .error error => IO.eprintln s!"deserialize {ixePath} failed: {error}"; return 1 + | .ok env => pure env + let selection : PairSelection ← match manifestPath? with + | none => + let nameA := (argStr args "--name-a").getD "False" + let nameB := (argStr args "--name-b").getD "True" + let leftBlocks ← match namedMicroShard env nameA with + | .error error => IO.eprintln error; return 1 + | .ok blocks => pure blocks + let rightBlocks ← match namedMicroShard env nameB with + | .error error => IO.eprintln error; return 1 + | .ok blocks => pure blocks + if leftBlocks == rightBlocks then + IO.eprintln s!"micro-shard names {nameA} and {nameB} resolve to the same block" + return 1 + pure { + leftBlocks, rightBlocks, leftId := 0, rightId := 1 + leftLabel := nameA, rightLabel := nameB + source := "init-named-microshards" + } + | some manifestPath => + let rawView ← match Ix.Cli.CheckCmd.parseIxesManifest + (← IO.FS.readBinFile manifestPath) 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, shardCounts) ← match rawView.pruneEmpty env with + | .error error => IO.eprintln error; return 1 + | .ok result => pure result + let (leftDense, rightDense) ← match requestedA?, requestedB? with + | none, none => match smallestSiblingPair? view.aggregationTree shardCounts with + | some pair => pure pair + | none => + IO.eprintln "manifest has no direct sibling leaf pair" + return 1 + | some requestedA, some requestedB => + let some denseA := view.shardIds.findIdx? (· == requestedA) + | IO.eprintln s!"manifest has no retained shard {requestedA}"; return 1 + let some denseB := view.shardIds.findIdx? (· == requestedB) + | IO.eprintln s!"manifest has no retained shard {requestedB}"; return 1 + pure (denseA, denseB) + | _, _ => + IO.eprintln "internal: partial shard override passed validation" + return 1 + let leftOriginal := view.shardIds[leftDense]! + let rightOriginal := view.shardIds[rightDense]! + pure { + leftBlocks := view.shards[leftDense]! + rightBlocks := view.shards[rightDense]! + leftId := leftOriginal + rightId := rightOriginal + leftLabel := s!"shard {leftOriginal}" + rightLabel := s!"shard {rightOriginal}" + expectedLeftSubjects? := some shardCounts[leftDense]! + expectedRightSubjects? := some shardCounts[rightDense]! + source := if requestedA?.isSome then "explicit-manifest-pair" + else "smallest-manifest-siblings" + manifestPath? := some manifestPath + } + let leftProofHex? := proofAHex? + let rightProofHex? := proofBHex? + let leftBlocks := selection.leftBlocks + let rightBlocks := selection.rightBlocks + let leftPrepared ← match prepareShard env leftBlocks with + | .error error => IO.eprintln s!"prepare {selection.leftLabel}: {error}"; return 1 + | .ok prepared => pure prepared + let rightPrepared ← match prepareShard env rightBlocks with + | .error error => IO.eprintln s!"prepare {selection.rightLabel}: {error}"; return 1 + | .ok prepared => pure prepared + if selection.expectedLeftSubjects?.any + (· != leftPrepared.statement.subjectCount) || + selection.expectedRightSubjects?.any + (· != rightPrepared.statement.subjectCount) then + IO.eprintln "internal: reconstructed subject counts differ from the manifest view" + return 1 + + let compactOps : Array FoldOp := #[.leaf 0, .leaf 1, .join 0 1] + let plan ← match schedulePlan compactOps + #[leftPrepared.statement.subjectCount, rightPrepared.statement.subjectCount] + structuralAbove with + | .error error => IO.eprintln error; return 1 + | .ok plan => pure plan + let some joinItem := plan[2]? + | IO.eprintln "internal: compact pair plan has no join slot"; return 1 + let mode := if joinItem.structural then "structural" else "flat" + let baseProofSource := if proofAHex?.isSome then "reused" else "generated" + IO.println (s!"[pair-bench] {selection.leftLabel}, {selection.rightLabel}: " ++ + s!"{leftPrepared.statement.subjectCount} + {rightPrepared.statement.subjectCount} " ++ + s!"subjects; {mode} join (threshold > {structuralAbove}); " ++ + s!"{baseProofSource} base proofs") + if hasFlag args "--plan-only" then return 0 + + let metadata : List (String × Json) := + [("schema-version", Lean.toJson (2 : Nat)), + ("ixe", Json.str ixePath), + ("ixes", selection.manifestPath?.map Json.str |>.getD Json.null), + ("left-shard", Lean.toJson selection.leftId), + ("right-shard", Lean.toJson selection.rightId), + ("left-label", Json.str selection.leftLabel), + ("right-label", Json.str selection.rightLabel), + ("left-subjects", Lean.toJson leftPrepared.statement.subjectCount), + ("right-subjects", Lean.toJson rightPrepared.statement.subjectCount), + ("pair-source", Json.str selection.source), + ("base-proof-source", Json.str baseProofSource), + ("queries", Lean.toJson queries), + ("join-mode", Json.str mode), + ("structural-above", Lean.toJson structuralAbove)] + let stagesRef ← IO.mkRef (#[] : Array (String × Json)) + let record (name : String) (row : Json) : IO Unit := do + let stages := (← stagesRef.get).push (name, row) + stagesRef.set stages + writeReport jsonPath? metadata "running" stages + IO.println s!"[pair-bench] recorded {name}" + writeReport jsonPath? metadata "running" #[] + + IO.println "[pair-bench] compiling IxVM and MultiStark systems" + let ixvmCompiled ← match ← compileToplevel "IxVM" IxVM.ixVM with + | .error error => IO.eprintln error; return 1 + | .ok compiled => pure compiled + let recursionCompiled ← match ← compileToplevel "MultiStark recursion" + MultiStark.multiStark with + | .error error => IO.eprintln error; return 1 + | .ok compiled => pure compiled + let verifyIdx := ixvmCompiled.getFuncIdx `verify_claim |>.get! + let liftIdx := recursionCompiled.getFuncIdx `verify_multi_stark_proof |>.get! + let joinIdx := recursionCompiled.getFuncIdx `join_two |>.get! + let structuralJoinIdx := recursionCompiled.getFuncIdx `join_two_structural |>.get! + let friParameters := benchmarkFriParameters queries + let recursionParameters : MultiStark.RecursionParameters := { + commitment := Aiur.defaultCommitmentParameters + fri := friParameters + } + let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode + Aiur.defaultCommitmentParameters friParameters + let recursionSystem := MultiStark.buildRecursionSystem recursionCompiled.bytecode + recursionParameters + let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with + | .error error => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {error}"; return 1 + | .ok handle => pure handle + let ixvmVk := ixvmSystem.vkBytes + let recursionVk := recursionSystem.vkBytes + let allowed := MultiStark.allowedBlob ixvmVk verifyIdx recursionVk liftIdx + joinIdx structuralJoinIdx + let specs ← match buildAggregateSlotSpecs plan #[leftPrepared, rightPrepared] + ixvmVk recursionVk allowed verifyIdx liftIdx joinIdx structuralJoinIdx + recursionParameters with + | .error error => IO.eprintln s!"prepare pair slots: {error}"; return 1 + | .ok specs => pure specs + let some leftSpec := specs[0]? + | IO.eprintln "internal: pair specs have no left lift"; return 1 + let some rightSpec := specs[1]? + | IO.eprintln "internal: pair specs have no right lift"; return 1 + let some rootSpec := specs[2]? + | IO.eprintln "internal: pair specs have no join"; return 1 + + let leftBase ← match leftProofHex? with + | some proofHex => + match ← reuseBaseProof "base-left" proofHex leftPrepared.claim record with + | .error error => + IO.eprintln error + writeReport jsonPath? metadata "error" (← stagesRef.get) + return 1 + | .ok result => pure result + | none => + let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks env leftBlocks + match ← runBaseProof "base-left" envHandle owned leftPrepared.claim + ixvmSystem verifyIdx record with + | .error error => + IO.eprintln error + writeReport jsonPath? metadata "error" (← stagesRef.get) + return 1 + | .ok result => pure result + let rightBase ← match rightProofHex? with + | some proofHex => + match ← reuseBaseProof "base-right" proofHex rightPrepared.claim record with + | .error error => + IO.eprintln error + writeReport jsonPath? metadata "error" (← stagesRef.get) + return 1 + | .ok result => pure result + | none => + let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks env rightBlocks + match ← runBaseProof "base-right" envHandle owned rightPrepared.claim + ixvmSystem verifyIdx record with + | .error error => + IO.eprintln error + writeReport jsonPath? metadata "error" (← stagesRef.get) + return 1 + | .ok result => pure result + + let left ← match ← runLift "lift-left" leftPrepared leftBase.wrapper leftSpec + ixvmSystem recursionSystem verifyIdx liftIdx ixvmVk record with + | .error error => + IO.eprintln error + writeReport jsonPath? metadata "error" (← stagesRef.get) + return 1 + | .ok slot => pure slot + let right ← match ← runLift "lift-right" rightPrepared rightBase.wrapper rightSpec + ixvmSystem recursionSystem verifyIdx liftIdx ixvmVk record with + | .error error => + IO.eprintln error + writeReport jsonPath? metadata "error" (← stagesRef.get) + return 1 + | .ok slot => pure slot + let root ← match ← runJoin joinItem left.slot right.slot rootSpec + recursionSystem joinIdx structuralJoinIdx recursionVk allowed record with + | .error error => + IO.eprintln error + writeReport jsonPath? metadata "error" (← stagesRef.get) + return 1 + | .ok slot => pure slot + + let expectedStatement := if joinItem.structural then + leftPrepared.statement.joinStructural rightPrepared.statement + else leftPrepared.statement.join rightPrepared.statement + if root.slot.statement.claim != expectedStatement.claim then + IO.eprintln "pair root statement differs from independent host reconstruction" + writeReport jsonPath? metadata "error" (← stagesRef.get) + return 1 + + -- Cheap negative control: the valid proof must reject under a one-word + -- mutation of its exact outer claim. + let some outerWord := root.slot.outerClaim[2]? + | IO.eprintln "internal: aggregate outer claim is shorter than three words"; return 1 + let wrongOuter := root.slot.outerClaim.set! 2 (outerWord + 1) + let (wrongResult, negativeSeconds) ← timed fun _ => + recursionSystem.verify wrongOuter root.slot.proof + match wrongResult with + | .ok () => + record "negative-control" (errorJson "proof accepted a mutated outer claim") + writeReport jsonPath? metadata "error" (← stagesRef.get) + return 1 + | .error _ => + record "negative-control" (stageJson [("seconds", jsonRound 6 negativeSeconds)]) + + let baseProveSeconds := leftBase.proveSeconds + rightBase.proveSeconds + let recursiveProveSeconds := left.proveSeconds + right.proveSeconds + root.proveSeconds + let serialProveSeconds := baseProveSeconds + recursiveProveSeconds + let parallelLowerBound := + max (leftBase.proveSeconds + left.proveSeconds) + (rightBase.proveSeconds + right.proveSeconds) + root.proveSeconds + let rootBytes := root.slot.proof.toBytes + let summary := stageJson + [("base-prove-seconds", jsonRound 6 baseProveSeconds), + ("recursive-prove-seconds", jsonRound 6 recursiveProveSeconds), + ("serial-total-prove-seconds", jsonRound 6 serialProveSeconds), + ("parallel-branch-lower-bound-seconds", jsonRound 6 parallelLowerBound), + ("root-proof-bytes", Lean.toJson rootBytes.size), + ("root-proof-digest", Json.str (toString (Address.blake3 rootBytes))), + ("subjects", Lean.toJson root.slot.subjectCount), + ("retains-assumptions", Lean.toJson root.slot.statement.assumptions.isSome)] + record "summary" summary + writeReport jsonPath? metadata "ok" (← stagesRef.get) + IO.println (s!"[pair-bench] OK: serial base proving {baseProveSeconds}s; " ++ + s!"recursive proving {recursiveProveSeconds}s; total {serialProveSeconds}s; " ++ + s!"parallel branch lower bound {parallelLowerBound}s; root {rootBytes.size} bytes") + pure 0 + +end Benchmarks.AggregatePair + +def main (args : List String) : IO UInt32 := + Benchmarks.AggregatePair.main args diff --git a/lakefile.lean b/lakefile.lean index 409361693..0b6446848 100644 --- a/lakefile.lean +++ b/lakefile.lean @@ -151,6 +151,10 @@ lean_exe «bench-recursion-debug» where root := `Benchmarks.RecursionDebug supportInterpreter := true +lean_exe «bench-aggregate-pair» where + root := `Benchmarks.AggregatePair + supportInterpreter := true + /- 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 From 319df803bb7db664a7f8c9818db89c16d0f6e3ff Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Fri, 28 Aug 2026 19:11:23 +0000 Subject: [PATCH 15/44] fmt, clippy --- crates/aiur/src/execute.rs | 19 +++++++++---------- crates/aiur/src/querymap.rs | 8 +++++++- crates/aiur/src/synthesis.rs | 26 +++++++++++++++++--------- crates/ffi/src/aiur/protocol.rs | 19 +++++++------------ crates/ffi/src/kernel.rs | 5 ++--- crates/kernel/src/shard.rs | 8 ++++++-- 6 files changed, 48 insertions(+), 37 deletions(-) diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index 73729b3fa..80e581052 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -52,8 +52,7 @@ impl QueryRecord { .functions .iter() .map(|f| { - let weight = - if f.constrained { f.layout.width() as u64 } else { 0 }; + let weight = if f.constrained { f.layout.width() as u64 } else { 0 }; QueryMap::new(f.layout.input_size, weight, profile) }) .collect(); @@ -372,8 +371,7 @@ impl Function { let mult = record.function_queries[*callee_idx].mult_at(i); if callee_unconstrained || !mult.is_zero() { if !callee_unconstrained { - let replay = - record.function_queries[*callee_idx].replay_at(i); + let replay = record.function_queries[*callee_idx].replay_at(i); record.virt += replay; } cached_output = Some( @@ -433,14 +431,16 @@ impl Function { .ok() .ok_or(ExecError::PointerTooLarge(ptr_u64))?; if ptr_usize >= memory_queries.len() { - return Err(ExecError::UnboundPointer { ptr: ptr_u64, size: *size }); + return Err(ExecError::UnboundPointer { + ptr: ptr_u64, + size: *size, + }); } if !unconstrained { record.virt += memory_queries.replay_at(ptr_usize); } - let (args, _) = memory_queries - .get_index(ptr_usize) - .expect("bounds checked above"); + let (args, _) = + memory_queries.get_index(ptr_usize).expect("bounds checked above"); map.extend_from_slice(args); }, ExecEntry::Op(Op::AssertEq(xs, ys, msg)) => { @@ -760,8 +760,7 @@ impl Function { if !unconstrained { record.virt += record.function_queries[fun_idx].weight(); } - let vsnap = - callers_states_stack.last().map_or(0, |cs| cs.vsnap); + let vsnap = callers_states_stack.last().map_or(0, |cs| cs.vsnap); record.function_queries[fun_idx].finish( &map[..input_size], &output, diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs index 5ba8a0cf0..94de70f93 100644 --- a/crates/aiur/src/querymap.rs +++ b/crates/aiur/src/querymap.rs @@ -363,7 +363,13 @@ impl QueryMap { /// (own-row touch included); recorded only when profiling. Function /// maps must insert exclusively through here so `vspans` stays aligned /// with the entry arenas. - pub fn finish(&mut self, key: &[G], output: &[G], constrained: bool, span: u64) { + pub fn finish( + &mut self, + key: &[G], + output: &[G], + constrained: bool, + span: u64, + ) { if let Some(i) = self.get_index_of(key) { // The only ordinary way to execute an already cached function is // constrained promotion of an unconstrained hint entry. diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 92aae29f8..601543d7e 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -354,21 +354,24 @@ impl AiurSystem { /// segments' vectors, in which case the result is an upper bound on /// the merged shard's peak. Gadget circuits are re-fixed to their /// constant heights internally, so dumb elementwise summation stays - /// valid. `None` on a length mismatch. + /// valid. `None` on a length mismatch or a value beyond `usize`. pub fn peak_of_raws(&self, raws: &[u64]) -> Option { let ncirc = self.system.circuits.len(); if raws.len() != ncirc + 1 { return None; } - let record_bytes = raws[ncirc] as usize; + let raws: Vec = raws + .iter() + .map(|&r| usize::try_from(r).ok()) + .collect::>()?; let peak = self .peak_prove_bytes_by( |i, ct| match ct { CircuitType::Bytes1 => 256, CircuitType::Bytes2 => 65536, - _ => raws[i] as usize, + _ => raws[i], }, - record_bytes, + raws[ncirc], ) .peak; Some(peak) @@ -524,9 +527,9 @@ impl AiurSystem { &mut IOBuffer, ) -> Result<(QueryRecord, Vec), ExecError>, { - match self - .prove_ixvm_within_budget(fun_idx, input, io_buffer, executor, None, false) - { + match self.prove_ixvm_within_budget( + fun_idx, input, io_buffer, executor, None, false, + ) { GatedProve::Proved { claim, proof, .. } => (claim, proof), _ => unreachable!("an unbudgeted prove always proves"), } @@ -586,8 +589,13 @@ impl AiurSystem { if exec_only { return GatedProve::Measured { peak }; } - let (claim, proof) = - self.prove_from_execution(fun_idx, input, io_buffer, query_record, &output); + let (claim, proof) = self.prove_from_execution( + fun_idx, + input, + io_buffer, + query_record, + &output, + ); GatedProve::Proved { claim, proof, peak } } diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index cc3d31466..7348f0841 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -7,8 +7,7 @@ use std::sync::LazyLock; use lean_ffi::object::{ ExternalClass, LeanArray, LeanBorrowed, LeanByteArray, LeanExcept, - LeanExternal, LeanNat, LeanOption, LeanOwned, LeanProd, LeanRef, - LeanString, + LeanExternal, LeanNat, LeanOption, LeanOwned, LeanProd, LeanRef, LeanString, }; use crate::{ @@ -419,11 +418,8 @@ extern "C" fn rs_aiur_qr_fn_vspan( ) -> LeanOwned { let idx = lean_unbox_nat_as_usize(fun_idx.inner()); let i = lean_unbox_nat_as_usize(i.inner()); - let span = handle - .get() - .function_queries - .get(idx) - .map_or(0, |m| m.vspan_at(i)); + let span = + handle.get().function_queries.get(idx).map_or(0, |m| m.vspan_at(i)); LeanOwned::box_usize(usize::try_from(span).expect("vspan fits usize")) } @@ -705,8 +701,7 @@ pub(crate) fn decode_addr_lists( return Err("addr lists: truncated addresses".into()); } lists.push( - ix_common::address::Address::unpack(&bytes[off..off + n * 32]) - .collect(), + ix_common::address::Address::unpack(&bytes[off..off + n * 32]).collect(), ); off += n * 32; } @@ -1232,9 +1227,9 @@ extern "C" fn rs_aiur_system_shard_prove_with_env( exec_only, ); let (proof, peak, parts) = match proved { - GatedProve::Proved { proof, peak, .. } => (LeanOption::some( - LeanExternal::alloc(&AIUR_PROOF_CLASS, proof), - ), peak, 1), + GatedProve::Proved { proof, peak, .. } => { + (LeanOption::some(LeanExternal::alloc(&AIUR_PROOF_CLASS, proof)), peak, 1) + }, GatedProve::Split { peak, parts } => (LeanOption::none(), peak, parts), GatedProve::Measured { peak } => (LeanOption::none(), peak, 1), }; diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index 02a5d7c24..ed2998ad8 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -41,9 +41,8 @@ use lean_ffi::object::LeanNat; use rustc_hash::FxHashMap; use lean_ffi::object::{ - LeanArray, LeanBool, LeanBorrowed, LeanByteArray, LeanExternal, - LeanIOResult, LeanList, LeanOption, LeanOwned, LeanProd, LeanRef, - LeanString, + LeanArray, LeanBool, LeanBorrowed, LeanByteArray, LeanExternal, LeanIOResult, + LeanList, LeanOption, LeanOwned, LeanProd, LeanRef, LeanString, }; use crate::lean::LeanIxCheckError; diff --git a/crates/kernel/src/shard.rs b/crates/kernel/src/shard.rs index a9e3eb70d..670d2a195 100644 --- a/crates/kernel/src/shard.rs +++ b/crates/kernel/src/shard.rs @@ -1672,7 +1672,8 @@ fn static_seed_shards_for_score(score: f64, ram_gib: u64) -> usize { let budget = ram_gib.max(1) as f64; let scaled = STATIC_SEED_REFERENCE_SHARDS * (score / STATIC_SEED_REFERENCE_SCORE).powf(STATIC_SEED_SCORE_EXPONENT) - * (STATIC_SEED_REFERENCE_RAM_GIB / budget).powf(STATIC_SEED_BUDGET_EXPONENT); + * (STATIC_SEED_REFERENCE_RAM_GIB / budget) + .powf(STATIC_SEED_BUDGET_EXPONENT); scaled.round().max(1.0) as usize } @@ -2643,7 +2644,10 @@ mod tests { spread.block(addr(i), 0, 1000, 1, OpCounts::default()); } - assert!(static_env_score(&concentrated.finish()) > static_env_score(&spread.finish())); + assert!( + static_env_score(&concentrated.finish()) + > static_env_score(&spread.finish()) + ); } #[test] From 6c20e1ce984e0522541fe8c6bbefad765d298581 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Fri, 28 Aug 2026 15:42:03 -0400 Subject: [PATCH 16/44] bench: measure aggregate flat joins Add an opt-in two-child benchmark that proves singleton CheckEnv shards, lifts both proofs, and measures a verified flat join. Wire join metrics through reporting and dashboards, and record the current pre-E2 lift-size baseline. --- Benchmarks/Typecheck.lean | 271 +++++++++++++++++++++++++++++++++--- Ix/Cli/BenchCmd.lean | 31 ++++- Ix/Cli/BenchPlots.lean | 6 + Tests/Ix/BenchMeasures.lean | 7 + docs/benchmarking.md | 24 +++- 5 files changed, 318 insertions(+), 21 deletions(-) diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean index 4bdd9e125..ca0aeed41 100644 --- a/Benchmarks/Typecheck.lean +++ b/Benchmarks/Typecheck.lean @@ -1,6 +1,7 @@ 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 @@ -42,8 +43,9 @@ lake exe bench-typecheck --ixe --consts [--consts-file

] [ 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 write per-constant results JSON to . Off by default: - normal CLI usage prints only the human-readable summary. + --json write results JSON to (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 , per-phase span timings are also written to .spans (JSON Lines) for the CI drill-down. Off by default. @@ -71,10 +73,19 @@ lake exe bench-typecheck --ixe --consts [--consts-file

] [ 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 + aggregate-first flat join after both singleton-CheckEnv + proofs have been lifted. 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 +102,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, lift both resulting + proofs, then execute/prove/verify `join_two`. 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 +126,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 +224,34 @@ structure Result where recursiveVerifySec : Option Float := none deriving Inhabited +/-- The successfully verified lift 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 join opens below it. -/ +structure LiftArtifact 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 `join_two` 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 +264,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. @@ -342,12 +407,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 — @@ -419,6 +496,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 +507,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 +537,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 +591,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 +619,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 lifted : Array LiftArtifact := #[] for i in [:ordered.size] do let (r, addr) := ordered[i]! if r.failed then continue @@ -542,8 +639,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 +661,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 +699,14 @@ 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 -- 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 + vkBytes innerClaimsBytes useInterp match rvRes with | .error e => IO.eprintln s!" ❌ recursive verifier REJECTED {r.name}'s proof: {e}" @@ -625,7 +732,7 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do TracingTexray.resetPeakTreeRss let ((rvClaim, rvProof), rvProveSec) ← timed fun _ => vSystem.proveMultiStark vIdx pubInput proofBytes vkBytes - claimBytes useInterp + innerClaimsBytes useInterp let rvPeak ← TracingTexray.peakTreeRssBytes let rvProofBytes := Aiur.Proof.toBytes rvProof let (rvVerifyRes, rvVerifySec) ← timed fun _ => @@ -644,13 +751,144 @@ 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 + lifted := lifted.push { + label := r.name + constants := r.constants + statement + innerClaimsBytes + checkEnvClaimBytes + outerClaim := rvClaim + proof := rvProof + } + | .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 flat aggregate join. The two + -- child rows remain ordinary IxVM/lift measurements; the shared join 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: flat join ──" + let leftLabel := targets[0]!.1 + let rightLabel := targets[1]!.1 + let pairName := s!"{leftLabel} + {rightLabel}" + let some left := lifted.find? fun artifact => artifact.label == leftLabel | do + IO.eprintln s!"join benchmark: no verified lift for {leftLabel}" + return 1 + let some right := lifted.find? fun artifact => artifact.label == rightLabel | do + IO.eprintln s!"join benchmark: no verified lift for {rightLabel}" + return 1 + let some (vCompiled, liftIdx, vSystem) := vCtx | do + IO.eprintln "join benchmark: recursion context was not built" + return 1 + let some joinIdx := vCompiled.getFuncIdx `join_two | do + IO.eprintln "join benchmark: join_two entrypoint missing" + return 1 + let some structuralJoinIdx := vCompiled.getFuncIdx `join_two_structural | do + IO.eprintln "join benchmark: join_two_structural entrypoint missing" + return 1 + let ixvmVk := aiurSystem.vkBytes + let recursionVk := vSystem.vkBytes + let allowed := MultiStark.allowedBlob ixvmVk funIdx recursionVk liftIdx + joinIdx structuralJoinIdx + let outputStatement := left.statement.join right.statement + let outputClaimBytes := Ix.Claim.ser outputStatement.claim + let pubInput := MultiStark.joinPubInput allowed outputClaimBytes + let leftOuterBytes := MultiStark.serializeClaims #[left.outerClaim] + let rightOuterBytes := MultiStark.serializeClaims #[right.outerClaim] + let preimagesBlob := MultiStark.joinPreimagesBlob + #[left.innerClaimsBytes, right.innerClaimsBytes, + left.checkEnvClaimBytes, right.checkEnvClaimBytes] + let treesBlob := MultiStark.joinTreesBlob <| + MultiStark.CheckEnvTrees.adviceTrees + left.statement right.statement outputStatement + let pathsBlob := MultiStark.joinPathsBlob #[] + IO.println s!" executing join {pairName} …" + (← IO.getStdout).flush + let (joinExecuteResult, joinExecuteSec) ← timed fun _ => + vCompiled.bytecode.executeMultiStarkJoin joinIdx pubInput + left.proof.toBytes right.proof.toBytes recursionVk + leftOuterBytes rightOuterBytes outputClaimBytes allowed + preimagesBlob treesBlob pathsBlob + let joinFftCost ← match joinExecuteResult with + | .error e => + IO.eprintln s!" ❌ join verifier REJECTED {pairName}: {e}" + writeRejectedJoin pairName + joinRejected := true + pure none + | .ok (_, queryCounts) => + let stats := Aiur.computeStats vCompiled queryCounts vSystem.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 _ => + vSystem.proveMultiStarkJoin joinIdx pubInput + left.proof.toBytes right.proof.toBytes recursionVk + leftOuterBytes rightOuterBytes 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 joinIdx 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 _ => + vSystem.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 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,10 +898,11 @@ 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)." texray; "Enable the tracing-texray timeline + RAM breakdown (per-prove spans on stderr). Combined with --json, per-phase span timings are additionally written to `.spans` as JSON Lines for the CI drill-down. Off by default." 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/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/docs/benchmarking.md b/docs/benchmarking.md index c6003c699..a30e93ca5 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,21 @@ a PR tree and compare them — exactly what the PR workflow does. | `compile` | `ix compile .lean → .ixe`: compile-time, file-size, constants, throughput | `ix compile --json` | | `decompile` | inverse of compile — `ix decompile .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. WP-E2 measures its proof-size delta against this value. + +The box-independent `--queries 0` join wiring gate produced a 246,014-byte +flat-join proof, 10,280,903,348 FFT cost, 6.57 s prove time, 10,798,899,200-byte +peak RSS, and 1.44 ms native verification. Those 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 From 5665aa3718af3068169db903a6fe525539f06728 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Sat, 22 Aug 2026 15:13:10 -0400 Subject: [PATCH 17/44] Bump Rust toolchain to 1.98 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - rust-toolchain.toml channel: 1.92 → 1.98, with the matching fenix toolchain hash in flake.nix. The pinned fenix already carries the 1.98 release manifest, so flake.lock needs no change (fenix's nixpkgs stays pinned via its lean4-nix follows, so the Lean toolchain is untouched). - Drop clippy::from_iter_instead_of_collect from the workspace lints: removed in clippy 1.98 and now warns as unknown. - Fix the warnings new clippy 1.98 lints surface across the workspace: chunks_exact(N) → as_chunks::() where the chunk size is constant, descending sort_by → sort_by_key(Reverse(..)), iteration over map values via .values(), map().unwrap_or() → map_or(), a checked division, an unwrap-after-is_some restructured into if-let, and assorted redundant-reference/pattern cleanups (mostly cargo clippy --fix). The two byte-gadget files keep their chunks_exact warnings until the next commit, which rewrites those regions anyway. CI derives its Rust version from rust-toolchain.toml, so no workflow changes are needed. --- Cargo.toml | 1 - crates/aiur/src/execute.rs | 11 ++------- crates/common/src/address.rs | 4 +++- crates/compile/src/compile.rs | 2 +- crates/compile/src/compile/aux_gen/brecon.rs | 6 ++--- .../compile/src/compile/aux_gen/cases_on.rs | 2 +- crates/compile/src/compile/env.rs | 2 +- crates/compile/src/compile/mutual.rs | 24 +++++++++---------- crates/ffi/src/aiur/protocol.rs | 8 +++++-- crates/ffi/src/kernel.rs | 2 +- crates/ffi/src/lean_env.rs | 4 ++-- crates/ffi/src/lean_ixon/sharing.rs | 2 +- crates/ixon/src/diff.rs | 2 +- crates/ixvm-codegen/src/aiur_ixvm_witness.rs | 4 +++- crates/kernel/src/def_eq.rs | 4 ++-- crates/kernel/src/inductive.rs | 11 ++------- crates/kernel/src/ingress.rs | 12 +--------- crates/kernel/src/perf.rs | 2 +- crates/kernel/src/tc.rs | 3 +-- crates/kernel/src/whnf.rs | 6 ++--- flake.nix | 2 +- rust-toolchain.toml | 2 +- 22 files changed, 48 insertions(+), 68 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index f535dd771..502f5ec59 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -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/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 { 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` chain in `memory[10]` from `limbs` (head-first order) 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 + '_ { 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 = Vec::new(); let mut ctor_args: Vec = 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 = 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 = Vec::new(); let mut wrapper_decls: Vec = 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 = 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 = 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 = 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 = 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 = 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 c7681563c..df59b1096 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -421,7 +421,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(), ) @@ -704,7 +706,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(), ); 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/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 { fn packed_digest_key(addr: &Address) -> Vec { addr .as_bytes() - .chunks_exact(4) + .as_chunks::<4>() + .0 + .iter() .map(|w| { G::from_u32( u32::from(w[0]) 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 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/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 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 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/flake.nix b/flake.nix index ce74d895f..9ebde2328 100644 --- a/flake.nix +++ b/flake.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/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" From b017104311c9994ea60907b685547b4ed96834fa Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Sat, 22 Aug 2026 15:13:10 -0400 Subject: [PATCH 18/44] Bump multi-stark: width-binding policy, height bound, P3 v0.6.0 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Companion to multi-stark's update-p3 branch (c72d321 → 249b740), which carries four soundness/robustness fixes and the Plonky3 v0.6.0 bump (pruned FRI Merkle multiproofs: ~2x faster verification, 40-70% smaller proofs; canonical Goldilocks serde removes proof-byte malleability). Proofs and verifying keys are not compatible with the previous pin. Integration: - Lookup gained max_multiplicity, a declared per-row bound on the multiplicity's integer magnitude feeding the newly enforced logUp height bound Σ wᵢ·hᵢ + |claims| < p. Function-circuit slots accumulate mutually-exclusive branch selectors, so they declare 1; committed count columns (function return slots, the memory circuit, the byte gadget tables) declare the new COUNT_COLUMN_BUDGET (2^32 queries per entry). - The VK wire format carries the bound: u64 LE max_multiplicity per lookup, between the multiplicity node id and the arg count. The in-circuit VK deserializer (Ix/MultiStark/SystemDeserialize.lean) parses past it; the value is bound through the vk digest but the height bound itself is not yet enforced in-circuit (the native verifier enforces it). - Message fingerprints are width-bound by default upstream (the slot width seeds the Horner fold), which is incompatible with aiur's branch-shared lookup slots: mutually exclusive branches superpose messages of different natural widths into one slot at the maximum width, so a narrow call is sent zero-padded to a width its callee's return slot never provides, and proving fails with UnbalancedChannel (pinned as the prove_verify_mismatched_call_widths regression). Aiur instead declares WidthBinding::ByConstruction — the plain Horner fold, restoring zero-padding transparency — and takes on the prefix-freeness contract that makes it sound: every message's natural width is a function of its constant-constrained leading prefix (channel tag plus discriminator: fun_idx fixes 2+in+out, the memory size coordinate fixes 3+size, each gadget tag fixes its table width), so zero-extension can only equate a padded message with its own natural form. The contract is documented at the channel constants in lib.rs; the declaration is applied in AiurSystem::build and mirrored in the vk_codec decoder so decoded VKs replay the same transcript. ByConstruction is also exactly the fold the in-circuit verifier's logup_fingerprint already computes, so the recursive verifier needs no fingerprint change. - The policy is Fiat-Shamir-bound as the first observe_shape word; the in-circuit transcript replay prepends the matching limb. - aiur_multi_stark.rs regenerated (ix codegen) for the deserializer and transcript changes. - P3 v0.6.0 ships FRI query openings as pruned Merkle multiproofs, while the in-circuit verifier consumes one authentication path per query (its per-query control flow is a far smaller circuit than the amortized multiproof walk). Rather than porting the walk into the DSL, the proof advice stays in the per-query transport: multi-stark's new advice module re-encodes a natively-verified proof by running p3's own verification with a recording compression function and reading each query's path back out of the recorded digest map. The advice bytes are untrusted verifier input, never digest-bound — the transcript binds the commitments and every expanded sibling is authenticated against them per query — so pruning vs expansion is pure transport and the encoding choice is sound. AiurSystem gains proof_to_advice_bytes (FFI: AiurSystem.proofToAdviceBytes); the recursive-verifier test feeds it instead of Proof.toBytes, whose native wire format is still round-tripped separately. The Lean-side proof grammar and the codegen'd verifier are byte-identical to before — no in-circuit changes. Claim layout, the VK wire format above and aiur's public semantics are otherwise unchanged; the policy adds no prover or verifier work over the previous pin. Still open, native-verifier-only: the logUp height bound is parsed past but not yet enforced in-circuit (a wide-arithmetic check, tracked separately). --- Cargo.lock | 215 +- Cargo.toml | 2 +- Ix/Aiur/Protocol.lean | 7 + Ix/MultiStark/SystemDeserialize.lean | 26 +- Ix/MultiStark/Verifier.lean | 9 +- Tests/MultiStark.lean | 10 +- crates/aiur/src/constraints.rs | 6 +- crates/aiur/src/gadgets/bytes1.rs | 18 +- crates/aiur/src/gadgets/bytes2.rs | 17 +- crates/aiur/src/lib.rs | 33 + crates/aiur/src/memory.rs | 6 +- crates/aiur/src/synthesis.rs | 104 +- crates/aiur/src/vk_codec.rs | 22 +- crates/ffi/src/aiur/protocol.rs | 18 + crates/ixvm-codegen/src/aiur_multi_stark.rs | 3768 ++++++++++--------- 15 files changed, 2377 insertions(+), 1884 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index eebdffbbc..82045f1fe 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", @@ -192,7 +192,7 @@ name = "bignat" version = "0.1.0" source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5" 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", @@ -1907,7 +1927,7 @@ 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 502f5ec59..2ef0aa97a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -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" diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index d1f5a913a..d0a41fb3c 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -210,6 +210,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/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/Tests/MultiStark.lean b/Tests/MultiStark.lean index a40acd77d..de662ff7a 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -161,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 @@ -205,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 := 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 { - 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/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> { 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::() + .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::() + .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::() + .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 = IndexMap; +/// 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> { 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, 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::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, v: usize) { buf.extend_from_slice(&v.to_le_bytes()); } +fn push_u64(buf: &mut Vec, 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, id: NodeId) { @@ -185,6 +190,7 @@ fn encode_circuit(buf: &mut Vec, circuit: &Circuit) { 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, 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/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index df59b1096..06ed9643b 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -164,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>, + claim: LeanArray>, + proof_obj: LeanExternal>, +) -> LeanExcept { + 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 diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index f73a10d04..a62e396e8 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -8569,13 +8569,23 @@ fn aiur_fn_88( 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_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 __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_87] = { let __args: [G; IN_87] = [__v_4, __v_3]; 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_5: G = __r_arr[0]; - let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_88] = [__v_1, __v_5, __v_6]; + 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); }) @@ -8606,20 +8616,30 @@ fn aiur_fn_89( 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_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 __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_87] = { let __args: [G; IN_87] = [__v_5, __v_4]; 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(1); - let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_7, __v_9]; 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_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_89] = [__v_13, __v_11]; + 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); }, @@ -9650,11 +9670,70 @@ fn aiur_fn_97( 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_235] = { let __args: [G; IN_235] = [__v_87, __v_107]; 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_108: G = __r_arr[0]; - let __ret: [G; OUT_97] = [__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]; + 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); }) @@ -22763,456 +22842,515 @@ fn aiur_fn_227( 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(0); - let __v_388: G = { let __values: [G; 10] = [__v_387, __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 __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_368, __v_388]; 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_389: G = __r_arr[0]; - let __v_390: 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_389, __v_379, __v_382, __v_383, __v_385, __v_390]; 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_391: G = __r_arr[0]; - let __v_392: 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_389, __v_379, __v_382, __v_383, __v_385, __v_392]; 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_393: G = __r_arr[0]; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_391, __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_394: G = __r_arr[0]; - let __v_395: G = __r_arr[1]; - let __v_396: G = __r_arr[2]; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_393, __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_397: G = __r_arr[0]; - let __v_398: G = __r_arr[1]; - let __v_399: G = __r_arr[2]; - let __v_400: G = G::from_u64(2); - let __v_401: G = G::from_u64(2); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_401]; let __info = io_buffer.get_info(__v_400, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_402: G = __io_pair.0; - let __v_403: G = __io_pair.1; - let __v_404: G = G::from_u64(2); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_404, __v_402, __v_403]; 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_405: G = __r_arr[0]; - let __v_406: G = G::from_u64(103); - let __v_407: G = G::from_u64(230); - let __v_408: G = G::from_u64(9); - let __v_409: G = G::from_u64(106); - let __v_410: G = G::from_u64(133); - let __v_411: G = G::from_u64(174); - let __v_412: G = G::from_u64(103); - let __v_413: G = G::from_u64(187); - let __v_414: G = G::from_u64(114); - let __v_415: G = G::from_u64(243); - let __v_416: G = G::from_u64(110); - let __v_417: G = G::from_u64(60); - let __v_418: G = G::from_u64(58); - let __v_419: G = G::from_u64(245); - let __v_420: G = G::from_u64(79); - let __v_421: G = G::from_u64(165); - let __v_422: G = G::from_u64(127); - let __v_423: G = G::from_u64(82); - let __v_424: G = G::from_u64(14); - let __v_425: G = G::from_u64(81); - let __v_426: G = G::from_u64(140); - let __v_427: G = G::from_u64(104); - let __v_428: G = G::from_u64(5); - let __v_429: G = G::from_u64(155); - let __v_430: G = G::from_u64(171); - let __v_431: G = G::from_u64(217); - let __v_432: G = G::from_u64(131); - let __v_433: G = G::from_u64(31); - let __v_434: G = G::from_u64(25); - let __v_435: G = G::from_u64(205); - let __v_436: G = G::from_u64(224); - let __v_437: G = G::from_u64(91); - let __v_438: G = G::from_u64(1); - let __v_439: G = G::from_u64(1); - let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_441: G = G::from_u64(0); - let __v_442: G = G::from_u64(0); - let __v_443: G = G::from_u64(0); - let __v_444: G = G::from_u64(0); - let __v_445: G = G::from_u64(0); - let __v_446: G = G::from_u64(0); - let __v_447: G = G::from_u64(0); - let __v_448: G = G::from_u64(0); - let __v_449: G = G::from_u64(0); - let __v_450: G = G::from_u64(0); - let __v_451: G = { let __values: [G; 8] = [__v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_449, __v_450]; 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_452: G = { let __values: [G; 32] = [__v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1); - let __v_454: G = G::from_u64(1); - let __v_455: G = { let __values: [G; 34] = [__v_453, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454]; 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_405, __v_440, __v_441, __v_442, __v_451, __v_452, __v_455]; 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_456: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_456]; 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_457: G = __r_arr[0]; - let __v_458: G = __r_arr[1]; - let __v_459: G = __r_arr[2]; - let __v_460: G = __r_arr[3]; - let __v_461: G = __r_arr[4]; - let __v_462: G = __r_arr[5]; - let __v_463: G = __r_arr[6]; - let __v_464: G = __r_arr[7]; - let __v_465: G = __r_arr[8]; - let __v_466: G = __r_arr[9]; - let __v_467: G = __r_arr[10]; - let __v_468: G = __r_arr[11]; - let __v_469: G = __r_arr[12]; - let __v_470: G = __r_arr[13]; - let __v_471: G = __r_arr[14]; - let __v_472: G = __r_arr[15]; - let __v_473: G = __r_arr[16]; - let __v_474: G = __r_arr[17]; - let __v_475: G = __r_arr[18]; - let __v_476: G = __r_arr[19]; - let __v_477: G = __r_arr[20]; - let __v_478: G = __r_arr[21]; - let __v_479: G = __r_arr[22]; - let __v_480: G = __r_arr[23]; - let __v_481: G = __r_arr[24]; - let __v_482: G = __r_arr[25]; - let __v_483: G = __r_arr[26]; - let __v_484: G = __r_arr[27]; - let __v_485: G = __r_arr[28]; - let __v_486: G = __r_arr[29]; - let __v_487: G = __r_arr[30]; - let __v_488: G = __r_arr[31]; - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_405]; 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_489: G = __r_arr[0]; - let __v_490: G = __r_arr[1]; - let __v_491: G = __r_arr[2]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_394]; 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_492: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_397]; 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_493: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_395, __v_396]; 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_494: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_398, __v_399]; 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_495: G = __r_arr[0]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_489]; 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_496: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_490, __v_491]; 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_497: G = __r_arr[0]; - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_492, __v_493, __v_496]; 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_494, __v_495, __v_496, __v_497]; 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_498: G = G::from_u64(96); - if (__v_19 != __v_498) { - return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_498.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); - } - let __v_499: G = G::from_u64(256); - let __v_500: G = (__v_499 * __v_74); - let __v_501: G = G::from_u64(65536); - let __v_502: G = (__v_501 * __v_75); - let __v_503: G = G::from_u64(16777216); - let __v_504: G = (__v_503 * __v_76); - let __v_505: G = (__v_502 + __v_504); - let __v_506: G = (__v_500 + __v_505); - let __v_507: G = (__v_73 + __v_506); - let __v_508: G = G::from_u64(256); - let __v_509: G = (__v_508 * __v_78); - let __v_510: G = G::from_u64(65536); - let __v_511: G = (__v_510 * __v_79); - let __v_512: G = G::from_u64(16777216); - let __v_513: G = (__v_512 * __v_80); - let __v_514: G = (__v_511 + __v_513); - let __v_515: G = (__v_509 + __v_514); - let __v_516: G = (__v_77 + __v_515); - let __v_517: G = G::from_u64(256); - let __v_518: G = (__v_517 * __v_82); - let __v_519: G = G::from_u64(65536); - let __v_520: G = (__v_519 * __v_83); - let __v_521: G = G::from_u64(16777216); - let __v_522: G = (__v_521 * __v_84); - let __v_523: G = (__v_520 + __v_522); - let __v_524: G = (__v_518 + __v_523); - let __v_525: G = (__v_81 + __v_524); - let __v_526: G = G::from_u64(256); - let __v_527: G = (__v_526 * __v_86); - let __v_528: G = G::from_u64(65536); - let __v_529: G = (__v_528 * __v_87); - let __v_530: G = G::from_u64(16777216); - let __v_531: G = (__v_530 * __v_88); - let __v_532: G = (__v_529 + __v_531); - let __v_533: G = (__v_527 + __v_532); - let __v_534: G = (__v_85 + __v_533); - let __v_535: G = G::from_u64(256); - let __v_536: G = (__v_535 * __v_90); - let __v_537: G = G::from_u64(65536); - let __v_538: G = (__v_537 * __v_91); - let __v_539: G = G::from_u64(16777216); - let __v_540: G = (__v_539 * __v_92); - let __v_541: G = (__v_538 + __v_540); - let __v_542: G = (__v_536 + __v_541); - let __v_543: G = (__v_89 + __v_542); - let __v_544: G = G::from_u64(256); - let __v_545: G = (__v_544 * __v_94); - let __v_546: G = G::from_u64(65536); - let __v_547: G = (__v_546 * __v_95); - let __v_548: G = G::from_u64(16777216); - let __v_549: G = (__v_548 * __v_96); - let __v_550: G = (__v_547 + __v_549); - let __v_551: G = (__v_545 + __v_550); - let __v_552: G = (__v_93 + __v_551); - let __v_553: G = G::from_u64(256); - let __v_554: G = (__v_553 * __v_98); - let __v_555: G = G::from_u64(65536); - let __v_556: G = (__v_555 * __v_99); - let __v_557: G = G::from_u64(16777216); - let __v_558: G = (__v_557 * __v_100); - let __v_559: G = (__v_556 + __v_558); - let __v_560: G = (__v_554 + __v_559); - let __v_561: G = (__v_97 + __v_560); - let __v_562: G = G::from_u64(256); - let __v_563: G = (__v_562 * __v_102); - let __v_564: G = G::from_u64(65536); - let __v_565: G = (__v_564 * __v_103); - let __v_566: G = G::from_u64(16777216); - let __v_567: G = (__v_566 * __v_104); - let __v_568: G = (__v_565 + __v_567); - let __v_569: G = (__v_563 + __v_568); - let __v_570: G = (__v_101 + __v_569); - if (__v_507 != __v_0) { - return Err(ExecError::AssertEqMismatch { lhs: __v_507.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_516 != __v_1) { - return Err(ExecError::AssertEqMismatch { lhs: __v_516.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_525 != __v_2) { - return Err(ExecError::AssertEqMismatch { lhs: __v_525.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_534 != __v_3) { - return Err(ExecError::AssertEqMismatch { lhs: __v_534.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_543 != __v_4) { - return Err(ExecError::AssertEqMismatch { lhs: __v_543.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_552 != __v_5) { - return Err(ExecError::AssertEqMismatch { lhs: __v_552.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_561 != __v_6) { - return Err(ExecError::AssertEqMismatch { lhs: __v_561.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_570 != __v_7) { - return Err(ExecError::AssertEqMismatch { lhs: __v_570.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + 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_571: G = __loaded[0]; - let __v_572: G = __loaded[1]; - let __v_573: G = __loaded[2]; - let __v_574: G = G::from_u64(1); - let __v_575: G = G::from_u64(1); - if (__v_571 != __v_574) { - return Err(ExecError::AssertEqMismatch { lhs: __v_571.as_canonical_u64(), rhs: __v_574.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); - } - if (__v_572 != __v_575) { - return Err(ExecError::AssertEqMismatch { lhs: __v_572.as_canonical_u64(), rhs: __v_575.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); - } - if (__v_573 != __v_575) { - return Err(ExecError::AssertEqMismatch { lhs: __v_573.as_canonical_u64(), rhs: __v_575.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); - } - let __v_576: G = G::from_u64(256); - let __v_577: G = (__v_576 * __v_251); - let __v_578: G = G::from_u64(65536); - let __v_579: G = (__v_578 * __v_252); - let __v_580: G = G::from_u64(16777216); - let __v_581: G = (__v_580 * __v_253); - let __v_582: G = (__v_579 + __v_581); - let __v_583: G = (__v_577 + __v_582); - let __v_584: G = (__v_250 + __v_583); - let __v_585: G = G::from_u64(256); - let __v_586: G = (__v_585 * __v_255); - let __v_587: G = G::from_u64(65536); - let __v_588: G = (__v_587 * __v_256); - let __v_589: G = G::from_u64(16777216); - let __v_590: G = (__v_589 * __v_257); - let __v_591: G = (__v_588 + __v_590); - let __v_592: G = (__v_586 + __v_591); - let __v_593: G = (__v_254 + __v_592); - let __v_594: G = G::from_u64(256); - let __v_595: G = (__v_594 * __v_259); - let __v_596: G = G::from_u64(65536); - let __v_597: G = (__v_596 * __v_260); - let __v_598: G = G::from_u64(16777216); - let __v_599: G = (__v_598 * __v_261); - let __v_600: G = (__v_597 + __v_599); - let __v_601: G = (__v_595 + __v_600); - let __v_602: G = (__v_258 + __v_601); - let __v_603: G = G::from_u64(256); - let __v_604: G = (__v_603 * __v_263); - let __v_605: G = G::from_u64(65536); - let __v_606: G = (__v_605 * __v_264); - let __v_607: G = G::from_u64(16777216); - let __v_608: G = (__v_607 * __v_265); - let __v_609: G = (__v_606 + __v_608); - let __v_610: G = (__v_604 + __v_609); - let __v_611: G = (__v_262 + __v_610); - let __v_612: G = G::from_u64(256); - let __v_613: G = (__v_612 * __v_267); - let __v_614: G = G::from_u64(65536); - let __v_615: G = (__v_614 * __v_268); - let __v_616: G = G::from_u64(16777216); - let __v_617: G = (__v_616 * __v_269); - let __v_618: G = (__v_615 + __v_617); - let __v_619: G = (__v_613 + __v_618); - let __v_620: G = (__v_266 + __v_619); - let __v_621: G = G::from_u64(256); - let __v_622: G = (__v_621 * __v_271); - let __v_623: G = G::from_u64(65536); - let __v_624: G = (__v_623 * __v_272); - let __v_625: G = G::from_u64(16777216); - let __v_626: G = (__v_625 * __v_273); - let __v_627: G = (__v_624 + __v_626); - let __v_628: G = (__v_622 + __v_627); - let __v_629: G = (__v_270 + __v_628); - let __v_630: G = G::from_u64(256); - let __v_631: G = (__v_630 * __v_275); - let __v_632: G = G::from_u64(65536); - let __v_633: G = (__v_632 * __v_276); - let __v_634: G = G::from_u64(16777216); - let __v_635: G = (__v_634 * __v_277); - let __v_636: G = (__v_633 + __v_635); - let __v_637: G = (__v_631 + __v_636); - let __v_638: G = (__v_274 + __v_637); - let __v_639: G = G::from_u64(256); - let __v_640: G = (__v_639 * __v_279); - let __v_641: G = G::from_u64(65536); - let __v_642: G = (__v_641 * __v_280); - let __v_643: G = G::from_u64(16777216); - let __v_644: G = (__v_643 * __v_281); - let __v_645: G = (__v_642 + __v_644); - let __v_646: G = (__v_640 + __v_645); - let __v_647: G = (__v_278 + __v_646); - if (__v_584 != __v_181) { - return Err(ExecError::AssertEqMismatch { lhs: __v_584.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_593 != __v_182) { - return Err(ExecError::AssertEqMismatch { lhs: __v_593.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_602 != __v_183) { - return Err(ExecError::AssertEqMismatch { lhs: __v_602.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_611 != __v_184) { - return Err(ExecError::AssertEqMismatch { lhs: __v_611.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_620 != __v_185) { - return Err(ExecError::AssertEqMismatch { lhs: __v_620.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_629 != __v_186) { - return Err(ExecError::AssertEqMismatch { lhs: __v_629.as_canonical_u64(), rhs: __v_186.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_638 != __v_187) { - return Err(ExecError::AssertEqMismatch { lhs: __v_638.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_647 != __v_188) { - return Err(ExecError::AssertEqMismatch { lhs: __v_647.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + 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_648: G = __loaded[0]; - let __v_649: G = __loaded[1]; - let __v_650: G = __loaded[2]; - let __v_651: G = G::from_u64(1); - let __v_652: G = G::from_u64(1); - if (__v_648 != __v_651) { - return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_651.as_canonical_u64(), msg: None }); - } - if (__v_649 != __v_652) { - return Err(ExecError::AssertEqMismatch { lhs: __v_649.as_canonical_u64(), rhs: __v_652.as_canonical_u64(), msg: None }); - } - if (__v_650 != __v_652) { - return Err(ExecError::AssertEqMismatch { lhs: __v_650.as_canonical_u64(), rhs: __v_652.as_canonical_u64(), msg: None }); - } - let __v_653: G = G::from_u64(256); - let __v_654: G = (__v_653 * __v_458); - let __v_655: G = G::from_u64(65536); - let __v_656: G = (__v_655 * __v_459); - let __v_657: G = G::from_u64(16777216); - let __v_658: G = (__v_657 * __v_460); - let __v_659: G = (__v_656 + __v_658); - let __v_660: G = (__v_654 + __v_659); - let __v_661: G = (__v_457 + __v_660); - let __v_662: G = G::from_u64(256); - let __v_663: G = (__v_662 * __v_462); - let __v_664: G = G::from_u64(65536); - let __v_665: G = (__v_664 * __v_463); - let __v_666: G = G::from_u64(16777216); - let __v_667: G = (__v_666 * __v_464); - let __v_668: G = (__v_665 + __v_667); - let __v_669: G = (__v_663 + __v_668); - let __v_670: G = (__v_461 + __v_669); - let __v_671: G = G::from_u64(256); - let __v_672: G = (__v_671 * __v_466); - let __v_673: G = G::from_u64(65536); - let __v_674: G = (__v_673 * __v_467); - let __v_675: G = G::from_u64(16777216); - let __v_676: G = (__v_675 * __v_468); - let __v_677: G = (__v_674 + __v_676); - let __v_678: G = (__v_672 + __v_677); - let __v_679: G = (__v_465 + __v_678); - let __v_680: G = G::from_u64(256); - let __v_681: G = (__v_680 * __v_470); - let __v_682: G = G::from_u64(65536); - let __v_683: G = (__v_682 * __v_471); - let __v_684: G = G::from_u64(16777216); - let __v_685: G = (__v_684 * __v_472); - let __v_686: G = (__v_683 + __v_685); - let __v_687: G = (__v_681 + __v_686); - let __v_688: G = (__v_469 + __v_687); - let __v_689: G = G::from_u64(256); - let __v_690: G = (__v_689 * __v_474); - let __v_691: G = G::from_u64(65536); - let __v_692: G = (__v_691 * __v_475); - let __v_693: G = G::from_u64(16777216); - let __v_694: G = (__v_693 * __v_476); - let __v_695: G = (__v_692 + __v_694); - let __v_696: G = (__v_690 + __v_695); - let __v_697: G = (__v_473 + __v_696); - let __v_698: G = G::from_u64(256); - let __v_699: G = (__v_698 * __v_478); - let __v_700: G = G::from_u64(65536); - let __v_701: G = (__v_700 * __v_479); - let __v_702: G = G::from_u64(16777216); - let __v_703: G = (__v_702 * __v_480); - let __v_704: G = (__v_701 + __v_703); - let __v_705: G = (__v_699 + __v_704); - let __v_706: G = (__v_477 + __v_705); - let __v_707: G = G::from_u64(256); - let __v_708: G = (__v_707 * __v_482); - let __v_709: G = G::from_u64(65536); - let __v_710: G = (__v_709 * __v_483); - let __v_711: G = G::from_u64(16777216); - let __v_712: G = (__v_711 * __v_484); - let __v_713: G = (__v_710 + __v_712); - let __v_714: G = (__v_708 + __v_713); - let __v_715: G = (__v_481 + __v_714); - let __v_716: G = G::from_u64(256); - let __v_717: G = (__v_716 * __v_486); - let __v_718: G = G::from_u64(65536); - let __v_719: G = (__v_718 * __v_487); - let __v_720: G = G::from_u64(16777216); - let __v_721: G = (__v_720 * __v_488); - let __v_722: G = (__v_719 + __v_721); - let __v_723: G = (__v_717 + __v_722); - let __v_724: G = (__v_485 + __v_723); - if (__v_661 != __v_8) { - return Err(ExecError::AssertEqMismatch { lhs: __v_661.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_670 != __v_9) { - return Err(ExecError::AssertEqMismatch { lhs: __v_670.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_679 != __v_10) { - return Err(ExecError::AssertEqMismatch { lhs: __v_679.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_688 != __v_11) { - return Err(ExecError::AssertEqMismatch { lhs: __v_688.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_697 != __v_12) { - return Err(ExecError::AssertEqMismatch { lhs: __v_697.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_706 != __v_13) { - return Err(ExecError::AssertEqMismatch { lhs: __v_706.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_715 != __v_14) { - return Err(ExecError::AssertEqMismatch { lhs: __v_715.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_724 != __v_15) { - return Err(ExecError::AssertEqMismatch { lhs: __v_724.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + 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)); }; @@ -23676,457 +23814,516 @@ fn aiur_fn_228( 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(0); - let __v_388: G = { let __values: [G; 10] = [__v_387, __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 __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_368, __v_388]; 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_389: G = __r_arr[0]; - let __v_390: 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_389, __v_379, __v_382, __v_383, __v_385, __v_390]; 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_391: G = __r_arr[0]; - let __v_392: 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_389, __v_379, __v_382, __v_383, __v_385, __v_392]; 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_393: G = __r_arr[0]; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_391, __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_394: G = __r_arr[0]; - let __v_395: G = __r_arr[1]; - let __v_396: G = __r_arr[2]; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_393, __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_397: G = __r_arr[0]; - let __v_398: G = __r_arr[1]; - let __v_399: G = __r_arr[2]; - let __v_400: G = G::from_u64(2); - let __v_401: G = G::from_u64(2); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_401]; let __info = io_buffer.get_info(__v_400, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_402: G = __io_pair.0; - let __v_403: G = __io_pair.1; - let __v_404: G = G::from_u64(2); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_404, __v_402, __v_403]; 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_405: G = __r_arr[0]; - let __v_406: G = G::from_u64(103); - let __v_407: G = G::from_u64(230); - let __v_408: G = G::from_u64(9); - let __v_409: G = G::from_u64(106); - let __v_410: G = G::from_u64(133); - let __v_411: G = G::from_u64(174); - let __v_412: G = G::from_u64(103); - let __v_413: G = G::from_u64(187); - let __v_414: G = G::from_u64(114); - let __v_415: G = G::from_u64(243); - let __v_416: G = G::from_u64(110); - let __v_417: G = G::from_u64(60); - let __v_418: G = G::from_u64(58); - let __v_419: G = G::from_u64(245); - let __v_420: G = G::from_u64(79); - let __v_421: G = G::from_u64(165); - let __v_422: G = G::from_u64(127); - let __v_423: G = G::from_u64(82); - let __v_424: G = G::from_u64(14); - let __v_425: G = G::from_u64(81); - let __v_426: G = G::from_u64(140); - let __v_427: G = G::from_u64(104); - let __v_428: G = G::from_u64(5); - let __v_429: G = G::from_u64(155); - let __v_430: G = G::from_u64(171); - let __v_431: G = G::from_u64(217); - let __v_432: G = G::from_u64(131); - let __v_433: G = G::from_u64(31); - let __v_434: G = G::from_u64(25); - let __v_435: G = G::from_u64(205); - let __v_436: G = G::from_u64(224); - let __v_437: G = G::from_u64(91); - let __v_438: G = G::from_u64(1); - let __v_439: G = G::from_u64(1); - let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_441: G = G::from_u64(0); - let __v_442: G = G::from_u64(0); - let __v_443: G = G::from_u64(0); - let __v_444: G = G::from_u64(0); - let __v_445: G = G::from_u64(0); - let __v_446: G = G::from_u64(0); - let __v_447: G = G::from_u64(0); - let __v_448: G = G::from_u64(0); - let __v_449: G = G::from_u64(0); - let __v_450: G = G::from_u64(0); - let __v_451: G = { let __values: [G; 8] = [__v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_449, __v_450]; 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_452: G = { let __values: [G; 32] = [__v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1); - let __v_454: G = G::from_u64(1); - let __v_455: G = { let __values: [G; 34] = [__v_453, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454]; 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_405, __v_440, __v_441, __v_442, __v_451, __v_452, __v_455]; 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_456: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_456]; 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_457: G = __r_arr[0]; - let __v_458: G = __r_arr[1]; - let __v_459: G = __r_arr[2]; - let __v_460: G = __r_arr[3]; - let __v_461: G = __r_arr[4]; - let __v_462: G = __r_arr[5]; - let __v_463: G = __r_arr[6]; - let __v_464: G = __r_arr[7]; - let __v_465: G = __r_arr[8]; - let __v_466: G = __r_arr[9]; - let __v_467: G = __r_arr[10]; - let __v_468: G = __r_arr[11]; - let __v_469: G = __r_arr[12]; - let __v_470: G = __r_arr[13]; - let __v_471: G = __r_arr[14]; - let __v_472: G = __r_arr[15]; - let __v_473: G = __r_arr[16]; - let __v_474: G = __r_arr[17]; - let __v_475: G = __r_arr[18]; - let __v_476: G = __r_arr[19]; - let __v_477: G = __r_arr[20]; - let __v_478: G = __r_arr[21]; - let __v_479: G = __r_arr[22]; - let __v_480: G = __r_arr[23]; - let __v_481: G = __r_arr[24]; - let __v_482: G = __r_arr[25]; - let __v_483: G = __r_arr[26]; - let __v_484: G = __r_arr[27]; - let __v_485: G = __r_arr[28]; - let __v_486: G = __r_arr[29]; - let __v_487: G = __r_arr[30]; - let __v_488: G = __r_arr[31]; - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_405]; 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_489: G = __r_arr[0]; - let __v_490: G = __r_arr[1]; - let __v_491: G = __r_arr[2]; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_394, __v_397]; 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_492: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_395, __v_396]; 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_493: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_398, __v_399]; 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_494: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_490, __v_491]; 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_495: G = __r_arr[0]; - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_493, __v_494, __v_489, __v_495]; 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_496: G = G::from_u64(96); - if (__v_19 != __v_496) { - return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_496.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); - } - let __v_497: G = G::from_u64(256); - let __v_498: G = (__v_497 * __v_74); - let __v_499: G = G::from_u64(65536); - let __v_500: G = (__v_499 * __v_75); - let __v_501: G = G::from_u64(16777216); - let __v_502: G = (__v_501 * __v_76); - let __v_503: G = (__v_500 + __v_502); - let __v_504: G = (__v_498 + __v_503); - let __v_505: G = (__v_73 + __v_504); - let __v_506: G = G::from_u64(256); - let __v_507: G = (__v_506 * __v_78); - let __v_508: G = G::from_u64(65536); - let __v_509: G = (__v_508 * __v_79); - let __v_510: G = G::from_u64(16777216); - let __v_511: G = (__v_510 * __v_80); - let __v_512: G = (__v_509 + __v_511); - let __v_513: G = (__v_507 + __v_512); - let __v_514: G = (__v_77 + __v_513); - let __v_515: G = G::from_u64(256); - let __v_516: G = (__v_515 * __v_82); - let __v_517: G = G::from_u64(65536); - let __v_518: G = (__v_517 * __v_83); - let __v_519: G = G::from_u64(16777216); - let __v_520: G = (__v_519 * __v_84); - let __v_521: G = (__v_518 + __v_520); - let __v_522: G = (__v_516 + __v_521); - let __v_523: G = (__v_81 + __v_522); - let __v_524: G = G::from_u64(256); - let __v_525: G = (__v_524 * __v_86); - let __v_526: G = G::from_u64(65536); - let __v_527: G = (__v_526 * __v_87); - let __v_528: G = G::from_u64(16777216); - let __v_529: G = (__v_528 * __v_88); - let __v_530: G = (__v_527 + __v_529); - let __v_531: G = (__v_525 + __v_530); - let __v_532: G = (__v_85 + __v_531); - let __v_533: G = G::from_u64(256); - let __v_534: G = (__v_533 * __v_90); - let __v_535: G = G::from_u64(65536); - let __v_536: G = (__v_535 * __v_91); - let __v_537: G = G::from_u64(16777216); - let __v_538: G = (__v_537 * __v_92); - let __v_539: G = (__v_536 + __v_538); - let __v_540: G = (__v_534 + __v_539); - let __v_541: G = (__v_89 + __v_540); - let __v_542: G = G::from_u64(256); - let __v_543: G = (__v_542 * __v_94); - let __v_544: G = G::from_u64(65536); - let __v_545: G = (__v_544 * __v_95); - let __v_546: G = G::from_u64(16777216); - let __v_547: G = (__v_546 * __v_96); - let __v_548: G = (__v_545 + __v_547); - let __v_549: G = (__v_543 + __v_548); - let __v_550: G = (__v_93 + __v_549); - let __v_551: G = G::from_u64(256); - let __v_552: G = (__v_551 * __v_98); - let __v_553: G = G::from_u64(65536); - let __v_554: G = (__v_553 * __v_99); - let __v_555: G = G::from_u64(16777216); - let __v_556: G = (__v_555 * __v_100); - let __v_557: G = (__v_554 + __v_556); - let __v_558: G = (__v_552 + __v_557); - let __v_559: G = (__v_97 + __v_558); - let __v_560: G = G::from_u64(256); - let __v_561: G = (__v_560 * __v_102); - let __v_562: G = G::from_u64(65536); - let __v_563: G = (__v_562 * __v_103); - let __v_564: G = G::from_u64(16777216); - let __v_565: G = (__v_564 * __v_104); - let __v_566: G = (__v_563 + __v_565); - let __v_567: G = (__v_561 + __v_566); - let __v_568: G = (__v_101 + __v_567); - if (__v_505 != __v_0) { - return Err(ExecError::AssertEqMismatch { lhs: __v_505.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_514 != __v_1) { - return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_523 != __v_2) { - return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_532 != __v_3) { - return Err(ExecError::AssertEqMismatch { lhs: __v_532.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_541 != __v_4) { - return Err(ExecError::AssertEqMismatch { lhs: __v_541.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_550 != __v_5) { - return Err(ExecError::AssertEqMismatch { lhs: __v_550.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_559 != __v_6) { - return Err(ExecError::AssertEqMismatch { lhs: __v_559.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_568 != __v_7) { - return Err(ExecError::AssertEqMismatch { lhs: __v_568.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + 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_569: G = __loaded[0]; - let __v_570: G = __loaded[1]; - let __v_571: G = __loaded[2]; - let __v_572: G = G::from_u64(1); - let __v_573: G = G::from_u64(1); - if (__v_569 != __v_572) { - return Err(ExecError::AssertEqMismatch { lhs: __v_569.as_canonical_u64(), rhs: __v_572.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); - } - if (__v_570 != __v_573) { - return Err(ExecError::AssertEqMismatch { lhs: __v_570.as_canonical_u64(), rhs: __v_573.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); - } - if (__v_571 != __v_573) { - return Err(ExecError::AssertEqMismatch { lhs: __v_571.as_canonical_u64(), rhs: __v_573.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); - } - let __v_574: G = G::from_u64(256); - let __v_575: G = (__v_574 * __v_251); - let __v_576: G = G::from_u64(65536); - let __v_577: G = (__v_576 * __v_252); - let __v_578: G = G::from_u64(16777216); - let __v_579: G = (__v_578 * __v_253); - let __v_580: G = (__v_577 + __v_579); - let __v_581: G = (__v_575 + __v_580); - let __v_582: G = (__v_250 + __v_581); - let __v_583: G = G::from_u64(256); - let __v_584: G = (__v_583 * __v_255); - let __v_585: G = G::from_u64(65536); - let __v_586: G = (__v_585 * __v_256); - let __v_587: G = G::from_u64(16777216); - let __v_588: G = (__v_587 * __v_257); - let __v_589: G = (__v_586 + __v_588); - let __v_590: G = (__v_584 + __v_589); - let __v_591: G = (__v_254 + __v_590); - let __v_592: G = G::from_u64(256); - let __v_593: G = (__v_592 * __v_259); - let __v_594: G = G::from_u64(65536); - let __v_595: G = (__v_594 * __v_260); - let __v_596: G = G::from_u64(16777216); - let __v_597: G = (__v_596 * __v_261); - let __v_598: G = (__v_595 + __v_597); - let __v_599: G = (__v_593 + __v_598); - let __v_600: G = (__v_258 + __v_599); - let __v_601: G = G::from_u64(256); - let __v_602: G = (__v_601 * __v_263); - let __v_603: G = G::from_u64(65536); - let __v_604: G = (__v_603 * __v_264); - let __v_605: G = G::from_u64(16777216); - let __v_606: G = (__v_605 * __v_265); - let __v_607: G = (__v_604 + __v_606); - let __v_608: G = (__v_602 + __v_607); - let __v_609: G = (__v_262 + __v_608); - let __v_610: G = G::from_u64(256); - let __v_611: G = (__v_610 * __v_267); - let __v_612: G = G::from_u64(65536); - let __v_613: G = (__v_612 * __v_268); - let __v_614: G = G::from_u64(16777216); - let __v_615: G = (__v_614 * __v_269); - let __v_616: G = (__v_613 + __v_615); - let __v_617: G = (__v_611 + __v_616); - let __v_618: G = (__v_266 + __v_617); - let __v_619: G = G::from_u64(256); - let __v_620: G = (__v_619 * __v_271); - let __v_621: G = G::from_u64(65536); - let __v_622: G = (__v_621 * __v_272); - let __v_623: G = G::from_u64(16777216); - let __v_624: G = (__v_623 * __v_273); - let __v_625: G = (__v_622 + __v_624); - let __v_626: G = (__v_620 + __v_625); - let __v_627: G = (__v_270 + __v_626); - let __v_628: G = G::from_u64(256); - let __v_629: G = (__v_628 * __v_275); - let __v_630: G = G::from_u64(65536); - let __v_631: G = (__v_630 * __v_276); - let __v_632: G = G::from_u64(16777216); - let __v_633: G = (__v_632 * __v_277); - let __v_634: G = (__v_631 + __v_633); - let __v_635: G = (__v_629 + __v_634); - let __v_636: G = (__v_274 + __v_635); - let __v_637: G = G::from_u64(256); - let __v_638: G = (__v_637 * __v_279); - let __v_639: G = G::from_u64(65536); - let __v_640: G = (__v_639 * __v_280); - let __v_641: G = G::from_u64(16777216); - let __v_642: G = (__v_641 * __v_281); - let __v_643: G = (__v_640 + __v_642); - let __v_644: G = (__v_638 + __v_643); - let __v_645: G = (__v_278 + __v_644); - if (__v_582 != __v_181) { - return Err(ExecError::AssertEqMismatch { lhs: __v_582.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_591 != __v_182) { - return Err(ExecError::AssertEqMismatch { lhs: __v_591.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_600 != __v_183) { - return Err(ExecError::AssertEqMismatch { lhs: __v_600.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_609 != __v_184) { - return Err(ExecError::AssertEqMismatch { lhs: __v_609.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_618 != __v_185) { - return Err(ExecError::AssertEqMismatch { lhs: __v_618.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_627 != __v_186) { - return Err(ExecError::AssertEqMismatch { lhs: __v_627.as_canonical_u64(), rhs: __v_186.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_636 != __v_187) { - return Err(ExecError::AssertEqMismatch { lhs: __v_636.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_645 != __v_188) { - return Err(ExecError::AssertEqMismatch { lhs: __v_645.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + 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_646: G = __loaded[0]; - let __v_647: G = __loaded[1]; - let __v_648: G = __loaded[2]; - let __v_649: G = G::from_u64(1); - let __v_650: G = G::from_u64(1); - if (__v_646 != __v_649) { - return Err(ExecError::AssertEqMismatch { lhs: __v_646.as_canonical_u64(), rhs: __v_649.as_canonical_u64(), msg: None }); - } - if (__v_647 != __v_650) { - return Err(ExecError::AssertEqMismatch { lhs: __v_647.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: None }); - } - if (__v_648 != __v_650) { - return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: None }); - } - let __v_651: G = G::from_u64(256); - let __v_652: G = (__v_651 * __v_458); - let __v_653: G = G::from_u64(65536); - let __v_654: G = (__v_653 * __v_459); - let __v_655: G = G::from_u64(16777216); - let __v_656: G = (__v_655 * __v_460); - let __v_657: G = (__v_654 + __v_656); - let __v_658: G = (__v_652 + __v_657); - let __v_659: G = (__v_457 + __v_658); - let __v_660: G = G::from_u64(256); - let __v_661: G = (__v_660 * __v_462); - let __v_662: G = G::from_u64(65536); - let __v_663: G = (__v_662 * __v_463); - let __v_664: G = G::from_u64(16777216); - let __v_665: G = (__v_664 * __v_464); - let __v_666: G = (__v_663 + __v_665); - let __v_667: G = (__v_661 + __v_666); - let __v_668: G = (__v_461 + __v_667); - let __v_669: G = G::from_u64(256); - let __v_670: G = (__v_669 * __v_466); - let __v_671: G = G::from_u64(65536); - let __v_672: G = (__v_671 * __v_467); - let __v_673: G = G::from_u64(16777216); - let __v_674: G = (__v_673 * __v_468); - let __v_675: G = (__v_672 + __v_674); - let __v_676: G = (__v_670 + __v_675); - let __v_677: G = (__v_465 + __v_676); - let __v_678: G = G::from_u64(256); - let __v_679: G = (__v_678 * __v_470); - let __v_680: G = G::from_u64(65536); - let __v_681: G = (__v_680 * __v_471); - let __v_682: G = G::from_u64(16777216); - let __v_683: G = (__v_682 * __v_472); - let __v_684: G = (__v_681 + __v_683); - let __v_685: G = (__v_679 + __v_684); - let __v_686: G = (__v_469 + __v_685); - let __v_687: G = G::from_u64(256); - let __v_688: G = (__v_687 * __v_474); - let __v_689: G = G::from_u64(65536); - let __v_690: G = (__v_689 * __v_475); - let __v_691: G = G::from_u64(16777216); - let __v_692: G = (__v_691 * __v_476); - let __v_693: G = (__v_690 + __v_692); - let __v_694: G = (__v_688 + __v_693); - let __v_695: G = (__v_473 + __v_694); - let __v_696: G = G::from_u64(256); - let __v_697: G = (__v_696 * __v_478); - let __v_698: G = G::from_u64(65536); - let __v_699: G = (__v_698 * __v_479); - let __v_700: G = G::from_u64(16777216); - let __v_701: G = (__v_700 * __v_480); - let __v_702: G = (__v_699 + __v_701); - let __v_703: G = (__v_697 + __v_702); - let __v_704: G = (__v_477 + __v_703); - let __v_705: G = G::from_u64(256); - let __v_706: G = (__v_705 * __v_482); - let __v_707: G = G::from_u64(65536); - let __v_708: G = (__v_707 * __v_483); - let __v_709: G = G::from_u64(16777216); - let __v_710: G = (__v_709 * __v_484); - let __v_711: G = (__v_708 + __v_710); - let __v_712: G = (__v_706 + __v_711); - let __v_713: G = (__v_481 + __v_712); - let __v_714: G = G::from_u64(256); - let __v_715: G = (__v_714 * __v_486); - let __v_716: G = G::from_u64(65536); - let __v_717: G = (__v_716 * __v_487); - let __v_718: G = G::from_u64(16777216); - let __v_719: G = (__v_718 * __v_488); - let __v_720: G = (__v_717 + __v_719); - let __v_721: G = (__v_715 + __v_720); - let __v_722: G = (__v_485 + __v_721); - if (__v_659 != __v_8) { - return Err(ExecError::AssertEqMismatch { lhs: __v_659.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_668 != __v_9) { - return Err(ExecError::AssertEqMismatch { lhs: __v_668.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_677 != __v_10) { - return Err(ExecError::AssertEqMismatch { lhs: __v_677.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_686 != __v_11) { - return Err(ExecError::AssertEqMismatch { lhs: __v_686.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_695 != __v_12) { - return Err(ExecError::AssertEqMismatch { lhs: __v_695.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_704 != __v_13) { - return Err(ExecError::AssertEqMismatch { lhs: __v_704.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_713 != __v_14) { - return Err(ExecError::AssertEqMismatch { lhs: __v_713.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_722 != __v_15) { - return Err(ExecError::AssertEqMismatch { lhs: __v_722.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_489, __v_492]; 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_723: G = __r_arr[0]; - let __v_724: G = G::from_u64(1); - if (__v_723 != __v_724) { - return Err(ExecError::AssertEqMismatch { lhs: __v_723.as_canonical_u64(), rhs: __v_724.as_canonical_u64(), msg: Some("structural join: output subject root is not nodeHash(left, right)".to_string()) }); + 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)); }; @@ -24439,145 +24636,204 @@ fn aiur_fn_229( 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_235] = { let __args: [G; IN_235] = [__v_241, __v_261]; 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_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_2] = { let __args: [G; IN_2] = [__v_267, __v_265, __v_266]; 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_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_68] = { let __args: [G; IN_68] = [__v_268, __v_303, __v_304, __v_305, __v_314, __v_315, __v_318]; 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_319: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_319]; 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_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_26] = { let __args: [G; IN_26] = [__v_268]; 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_352: G = __r_arr[0]; - let __v_353: G = __r_arr[1]; - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_353, __v_352]; 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_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_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_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 __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 __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_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 __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_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 __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_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 __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_362: G = __r_arr[0]; - let __v_363: G = G::from_u64(1); - if (__v_362 != __v_363) { - return Err(ExecError::AssertEqMismatch { lhs: __v_362.as_canonical_u64(), rhs: __v_363.as_canonical_u64(), msg: None }); + let __v_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_364: G = G::from_u64(1); - break '__mc_0 [__v_364]; + 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() { @@ -24585,17 +24841,17 @@ fn aiur_fn_229( match __v_22.as_canonical_u64() { _ => { 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_357: G = __r_arr[0]; + 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_358: G = __r_arr[0]; + 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]; @@ -24605,521 +24861,521 @@ fn aiur_fn_229( }, } }; - let __v_359: G = __mc_out___mc_2[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_34, __v_268]; 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_360: G = __r_arr[0]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_24, __v_360]; 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_361: G = __r_arr[0]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_359, __v_361]; 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_362: G = __r_arr[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_22, __v_362]; 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_363: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_262, __v_363]; 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_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_155] = { let __args: [G; IN_155] = [__v_406, __v_409]; 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_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_149] = { let __args: [G; IN_149] = [__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[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_431: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[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_432: G = __r_arr[0]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_426, __v_432]; 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_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_155] = { let __args: [G; IN_155] = [__v_433, __v_436]; 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_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_149] = { let __args: [G; IN_149] = [__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[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_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_149] = { let __args: [G; IN_149] = [__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[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_459: G = __r_arr[0]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_453, __v_459]; 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_460: G = __r_arr[0]; - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_460, __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_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_119] = { let __args: [G; IN_119] = [__v_30, __v_464]; 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_465: G = __r_arr[0]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_461, __v_465]; 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_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_155] = { let __args: [G; IN_155] = [__v_466, __v_469]; 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_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_159] = { let __args: [G; IN_159] = [__v_486, __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_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_155] = { let __args: [G; IN_155] = [__v_488, __v_491]; 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_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_185] = { let __args: [G; IN_185] = [__v_678, __v_679, __v_354, __v_530, __v_551, __v_572, __v_593]; 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_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_183] = { let __args: [G; IN_183] = [__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[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_683: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_357]; 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_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_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_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 __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_121] = { let __args: [G; IN_121] = [__v_60, __v_688]; 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_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_121] = { let __args: [G; IN_121] = [__v_57, __v_689]; 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_690: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_64, __v_690]; 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_691: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_62, __v_691]; 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_692: G = __r_arr[0]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_508, __v_692]; 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_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_155] = { let __args: [G; IN_155] = [__v_693, __v_696]; 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_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_125] = { let __args: [G; IN_125] = [__v_713, __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_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_119] = { let __args: [G; IN_119] = [__v_46, __v_761]; 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_762: G = __r_arr[0]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_758, __v_762]; 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_763: G = __r_arr[0]; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_763, __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_764: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__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[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_765: G = __r_arr[0]; - let __v_766: G = __r_arr[1]; - let __v_767: G = (__v_685 + __v_155); + 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_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_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_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_770: G = __r_arr[0]; + 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_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 __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_241] = { let __args: [G; IN_241] = [__v_357]; 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_775: 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_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_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 __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_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_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 __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_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_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 __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_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_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 __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_145] = { let __args: [G; IN_145] = [__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[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_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]; }, } }, @@ -25131,240 +25387,240 @@ fn aiur_fn_229( }, } }; - 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 __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)); }; From 093365d4c7f32e276696a8b93ea21fe4da100e03 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Mon, 24 Aug 2026 14:00:15 -0400 Subject: [PATCH 19/44] Bump Blake3.lean and lean-ffi for Rust 1.98 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The Lean v4.33.1 update pinned both dependencies at revisions that predate their Rust 1.98 bumps; their heads now carry those bumps, which this workspace needs since rust-toolchain.toml moved to 1.98. Both revisions stay on leanprover/lean4:v4.33.1. - Blake3.lean 1b0fbd2 → e6e908b (Rust 1.98, plus a case-insensitive source-directory fix), updated in lakefile.lean, lake-manifest.json and the blake3-lean flake input. The revision keeps the `blake3_rs_shared` target the `ix_native_decide_dynlib` pin requires. The inherited entry in Benchmarks/Compile/lake-manifest.json was still on the pre-4.33.1 revision and now tracks the root pin. - lean-ffi 2a9c91e → 93c7e52 (Rust 1.98). Only bignat reaches the sp1 and zisk workspaces, so their lock files move that one package. --- Benchmarks/Compile/lake-manifest.json | 4 ++-- Cargo.lock | 4 ++-- Cargo.toml | 4 ++-- flake.lock | 8 ++++---- flake.nix | 2 +- lake-manifest.json | 4 ++-- lakefile.lean | 2 +- sp1/Cargo.lock | 2 +- sp1/guest/Cargo.lock | 2 +- zisk/Cargo.lock | 2 +- zisk/agg-guest/Cargo.lock | 2 +- zisk/guest/Cargo.lock | 2 +- 12 files changed, 19 insertions(+), 19 deletions(-) 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/Cargo.lock b/Cargo.lock index 82045f1fe..581bc3ce1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -190,7 +190,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", ] @@ -1922,7 +1922,7 @@ 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", diff --git a/Cargo.toml b/Cargo.toml index 2ef0aa97a..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" 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 9ebde2328..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"; }; 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 0b6446848..fbd074f59 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" 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", ] From 428d6ac8db2fa8cb59bdb69287e4b11e8682bfb4 Mon Sep 17 00:00:00 2001 From: samuelburnham <45365069+samuelburnham@users.noreply.github.com> Date: Mon, 24 Aug 2026 17:55:08 -0400 Subject: [PATCH 20/44] bench: feed the recursive phase advice bytes, fix RecursionDebug's claim MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The !benchmark recursive phase reported n/a for every fri-verifier metric: Benchmarks/Typecheck.lean still fed Proof.toBytes — the pruned multiproof wire format — to executeMultiStark/proveMultiStark, so the in-circuit verifier rejected on parse and the harness (correctly) left the recursive fields absent rather than emit a fake datum. The in-circuit verifier consumes the per-query advice transport (AiurSystem.proofToAdviceBytes); proofBytes stays the reported proof-size metric. bench-recursion-debug had the same advice-format gap plus a stale claim recipe: it still built the public input as 32 raw digest bytes, predating the ClaimHarness.packedDigestKey packing bench-typecheck uses (its own out-of-circuit sanity check failed with InvalidPowWitness — a wrong claim diverges every challenge — and the advice re-encoder refused the proof for the same reason). Both aligned with the typecheck flow. Validated end-to-end at production parameters (numQueries 100, query PoW 20, blowup 2) on Nat.add_comm: inner prove, advice re-encoding, and the codegen'd in-circuit verifier accepting. --- Benchmarks/RecursionDebug.lean | 17 +++++++++++------ Benchmarks/Typecheck.lean | 12 ++++++++++-- 2 files changed, 21 insertions(+), 8 deletions(-) diff --git a/Benchmarks/RecursionDebug.lean b/Benchmarks/RecursionDebug.lean index 1b5bff892..9b3f04607 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" diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean index ca0aeed41..d34766d7c 100644 --- a/Benchmarks/Typecheck.lean +++ b/Benchmarks/Typecheck.lean @@ -702,10 +702,18 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do let innerClaimsBytes := MultiStark.serializeClaims #[claim] let vkBytes := aiurSystem.vkBytes 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 + vCompiled.bytecode.executeMultiStark vIdx pubInput adviceBytes vkBytes innerClaimsBytes useInterp match rvRes with | .error e => @@ -731,7 +739,7 @@ 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 + vSystem.proveMultiStark vIdx pubInput adviceBytes vkBytes innerClaimsBytes useInterp let rvPeak ← TracingTexray.peakTreeRssBytes let rvProofBytes := Aiur.Proof.toBytes rvProof From 4a265c7c6c641871b7944a6753326c35d63f7407 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Sat, 29 Aug 2026 07:19:42 -0400 Subject: [PATCH 21/44] aggregate: adapt recursion pipeline to pruned FRI proofs Keep compact proof bytes at storage and cache boundaries, expand them only for recursive lift/join advice, reject unsupported zero-query benchmarks, and decode legacy store proofs without panicking. Refresh tests, benchmark pins, and Rust 1.98 lint compatibility. --- Benchmarks/AggregatePair.lean | 19 ++++++- Benchmarks/RecursionDebug.lean | 3 + Benchmarks/Typecheck.lean | 24 ++++++-- Ix/Aiur/Protocol.lean | 16 ++++-- Ix/Aiur/Semantics/BytecodeFfi.lean | 9 ++- Ix/Cli/AggregateCmd.lean | 17 +++++- Ix/Cli/VerifyCmd.lean | 12 +++- Ix/MultiStark.lean | 5 +- Tests/MultiStark.lean | 55 +++++++++++++------ Tests/MultiStarkActivation.lean | 29 ++++++---- crates/ffi/src/aiur/protocol.rs | 13 +++-- crates/ffi/src/catalog.rs | 10 ++-- .../src/aiur_multi_stark_runner.rs | 8 +-- docs/benchmarking.md | 27 +++++++-- 14 files changed, 178 insertions(+), 69 deletions(-) diff --git a/Benchmarks/AggregatePair.lean b/Benchmarks/AggregatePair.lean index 81e451c9d..cab3975fc 100644 --- a/Benchmarks/AggregatePair.lean +++ b/Benchmarks/AggregatePair.lean @@ -260,13 +260,18 @@ def runLift (label : String) (prepared : PreparedShard) (wrapper : Ixon.Proof) ("peak-rss-bytes", Lean.toJson innerVerifyPeak), ("proof-bytes", Lean.toJson wrapper.proof.size)]) + let innerProofAdvice ← match ixvmSystem.proofToAdviceBytes innerClaim innerProof with + | .error error => + return .error s!"{label}: inner proof advice encoding failed: {error}" + | .ok bytes => pure bytes + let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] let pubInput := MultiStark.verifierPubInput ixvmVk innerClaimsBytes IO.println s!"[pair-bench] proving {label}" (← IO.getStdout).flush TracingTexray.resetPeakTreeRss let ((outerClaim, proof), proveSeconds) ← timed fun _ => - recursionSystem.proveMultiStark liftIdx pubInput wrapper.proof ixvmVk innerClaimsBytes + recursionSystem.proveMultiStark liftIdx pubInput innerProofAdvice ixvmVk innerClaimsBytes let provePeak ← TracingTexray.peakTreeRssBytes if outerClaim != spec.outerClaim then let error := "produced an unexpected outer claim" @@ -326,13 +331,23 @@ def runJoin (item : ScheduledFold) (left right : AggregateSlot) else MultiStark.joinPathsBlob #[] let joinFunIdx := if item.structural then structuralJoinIdx else joinIdx let label := if item.structural then "structural-join" else "flat-join" + let leftProofAdvice ← match recursionSystem.proofToAdviceBytes + left.outerClaim left.proof with + | .error error => + return .error s!"{label}: left child proof advice encoding failed: {error}" + | .ok bytes => pure bytes + let rightProofAdvice ← match recursionSystem.proofToAdviceBytes + right.outerClaim right.proof with + | .error error => + return .error s!"{label}: right child proof advice encoding failed: {error}" + | .ok bytes => pure bytes IO.println s!"[pair-bench] proving {label}" (← IO.getStdout).flush TracingTexray.resetPeakTreeRss let (proved, proveSeconds) ← timed fun _ => recursionSystem.proveMultiStarkJoin joinFunIdx pubInput - left.proof.toBytes right.proof.toBytes recursionVk + leftProofAdvice rightProofAdvice recursionVk leftClaimsBytes rightClaimsBytes outputClaimBytes allowed preimagesBlob treesBlob pathsBlob let provePeak ← TracingTexray.peakTreeRssBytes diff --git a/Benchmarks/RecursionDebug.lean b/Benchmarks/RecursionDebug.lean index 9b3f04607..166c609e9 100644 --- a/Benchmarks/RecursionDebug.lean +++ b/Benchmarks/RecursionDebug.lean @@ -130,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 d34766d7c..a1760dfbd 100644 --- a/Benchmarks/Typecheck.lean +++ b/Benchmarks/Typecheck.lean @@ -398,6 +398,10 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do IO.eprintln "error: provide at least one constant via --consts and/or --consts-file " 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" @@ -463,7 +467,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 @@ -826,11 +830,23 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do MultiStark.CheckEnvTrees.adviceTrees left.statement right.statement outputStatement let pathsBlob := MultiStark.joinPathsBlob #[] + let leftProofAdvice ← match vSystem.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 vSystem.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 IO.println s!" executing join {pairName} …" (← IO.getStdout).flush let (joinExecuteResult, joinExecuteSec) ← timed fun _ => vCompiled.bytecode.executeMultiStarkJoin joinIdx pubInput - left.proof.toBytes right.proof.toBytes recursionVk + leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes outputClaimBytes allowed preimagesBlob treesBlob pathsBlob let joinFftCost ← match joinExecuteResult with @@ -852,7 +868,7 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do TracingTexray.resetPeakTreeRss let (joinProveResult, joinProveSec) ← timed fun _ => vSystem.proveMultiStarkJoin joinIdx pubInput - left.proof.toBytes right.proof.toBytes recursionVk + leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes outputClaimBytes allowed preimagesBlob treesBlob pathsBlob match joinProveResult with @@ -912,7 +928,7 @@ def typecheckCmd : Cli.Cmd := `[Cli| "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 `.spans` as JSON Lines for the CI drill-down. Off by default." ] diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index d0a41fb3c..3f8311918 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -145,8 +145,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 @@ -157,11 +159,13 @@ 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 raw child -proof/claim advice. The compact preimage/tree/path blobs are produced by +/-- 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 @@ -170,7 +174,7 @@ intentionally not marshalled back to Lean. -/ @[extern "rs_aiur_multi_stark_join_prove"] opaque proveMultiStarkJoin (system : @& AiurSystem) (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G) - (leftProofBytes rightProofBytes recursionVkBytes : @& ByteArray) + (leftProofAdviceBytes rightProofAdviceBytes recursionVkBytes : @& ByteArray) (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray) (preimagesBlob treesBlob pathsBlob : @& ByteArray) (useBytecode : Bool := false) : Except String (Array G × Proof) diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index caf215306..564c49513 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,11 +173,12 @@ 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 proofs/claims and the fixed vk/output/allowed blobs are passed without +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. @@ -185,7 +188,7 @@ generated production verifier. -/ @[extern "rs_aiur_multi_stark_join_execute"] opaque executeMultiStarkJoin (toplevel : @& Bytecode.Toplevel) (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G) - (leftProofBytes rightProofBytes recursionVkBytes : @& ByteArray) + (leftProofAdviceBytes rightProofAdviceBytes recursionVkBytes : @& ByteArray) (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray) (preimagesBlob treesBlob pathsBlob : @& ByteArray) (useBytecode : Bool := false) : Except String (Array G × Array QueryCount) diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index 467367125..1318f48ca 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -629,11 +629,16 @@ private def proveAggregateSlot (ctx : AggregateProveContext) (slotIdx : Nat) 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 pubInput := MultiStark.verifierPubInput ctx.ixvmVk innerClaimsBytes IO.println s!"[aggregate] lifting shard {originalShard} into slot {slotIdx}" (← IO.getStdout).flush let (outerClaim, proof) := ctx.recursionSystem.proveMultiStark - ctx.liftIdx pubInput wrapper.proof ctx.ixvmVk innerClaimsBytes + ctx.liftIdx pubInput innerProofAdvice ctx.ixvmVk innerClaimsBytes if outerClaim != spec.outerClaim then return .error "lift produced an unexpected outer claim" let proofAddress? ← match ctx.cacheDir? with @@ -681,10 +686,18 @@ private def proveAggregateSlot (ctx : AggregateProveContext) (slotIdx : Nat) MultiStark.joinPathsBlob #[] let joinFunIdx := if item.structural then ctx.structuralJoinIdx else ctx.joinIdx let mode := if item.structural then "structural" else "flat" + let leftProofAdvice ← match ctx.recursionSystem.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 ctx.recursionSystem.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 result := ctx.recursionSystem.proveMultiStarkJoin joinFunIdx pubInput - left.proof.toBytes right.proof.toBytes ctx.recursionVk + leftProofAdvice rightProofAdvice ctx.recursionVk leftClaimsBytes rightClaimsBytes outputClaimBytes ctx.allowed preimagesBlob treesBlob pathsBlob let (outerClaim, proof) ← match result with diff --git a/Ix/Cli/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean index ff410f780..e8db79e3a 100644 --- a/Ix/Cli/VerifyCmd.lean +++ b/Ix/Cli/VerifyCmd.lean @@ -52,7 +52,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) @@ -204,7 +208,11 @@ private def verifyAggregateProof (backend : AggregateBackend) IO.eprintln s!"error: aggregate claim {wrapper.claim} does not match expected {expected.claim}" return 1 | none => pure () - 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: aggregate proof {proofAddr} does not decode: {e}" + return 1 let claimBytes := Ix.Claim.ser wrapper.claim let joinPubInput := MultiStark.joinPubInput backend.allowed claimBytes let outerClaim : AggregateRootKind → Array Aiur.G diff --git a/Ix/MultiStark.lean b/Ix/MultiStark.lean index 47f02a47d..393b7eb07 100644 --- a/Ix/MultiStark.lean +++ b/Ix/MultiStark.lean @@ -188,8 +188,9 @@ 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 => diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index de662ff7a..21e373e0f 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -416,6 +416,12 @@ def joinSmokeSuite : IO UInt32 := do (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 @@ -551,8 +557,8 @@ def joinSmokeSuite : IO UInt32 := do let oneKey := #[Aiur.G.ofNat 1] let twoKey := #[Aiur.G.ofNat 2] let io := seedJoinTrees ((default : IOBuffer) - |>.extend 0 zeroKey (bytesAsGs leftProof.toBytes) - |>.extend 0 oneKey (bytesAsGs rightProof.toBytes) + |>.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) @@ -574,7 +580,7 @@ def joinSmokeSuite : IO UInt32 := do let structuralJoinIdx := compiled.getFuncIdx `join_two_structural |>.get! let honestInterp := compiled.bytecode.execute joinIdx pubInput io let honest := compiled.bytecode.executeMultiStarkJoin joinIdx pubInput - leftProof.toBytes rightProof.toBytes recursionVk leftOuterBytes rightOuterBytes + leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes outputClaimBytes allowed preimagesBlob treesBlob emptyPathsBlob let nativeParity : Bool := match honest, honestInterp with | .ok (out, qc), .ok (outI, _, qcI) => @@ -584,7 +590,7 @@ def joinSmokeSuite : IO UInt32 := do | _, _ => false let malformedFraming := compiled.bytecode.executeMultiStarkJoin joinIdx pubInput - leftProof.toBytes rightProof.toBytes recursionVk leftOuterBytes rightOuterBytes + leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes outputClaimBytes allowed ⟨#[]⟩ treesBlob emptyPathsBlob -- Structural mode commits to `nodeHash(leftRoot, rightRoot)` and replaces @@ -599,11 +605,11 @@ def joinSmokeSuite : IO UInt32 := do leftStatement rightStatement structuralOutput let structuralPathsBlob := MultiStark.joinPathsBlob structuralPathAdvice let structuralHonest := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx - structuralInput leftProof.toBytes rightProof.toBytes recursionVk + structuralInput leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes structuralClaimBytes allowed preimagesBlob structuralTreesBlob structuralPathsBlob let structuralInterp := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx - structuralInput leftProof.toBytes rightProof.toBytes recursionVk + structuralInput leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes structuralClaimBytes allowed preimagesBlob structuralTreesBlob structuralPathsBlob true let structuralParity : Bool := match structuralHonest, structuralInterp with @@ -624,7 +630,7 @@ def joinSmokeSuite : IO UInt32 := do if candidate == a then (candidate, leftSubjects.merkleProof candidate) else (candidate, path?) let wrongRootPath := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx - structuralInput leftProof.toBytes rightProof.toBytes recursionVk + structuralInput leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes structuralClaimBytes allowed preimagesBlob structuralTreesBlob (MultiStark.joinPathsBlob wrongRootPathAdvice) @@ -638,7 +644,7 @@ def joinSmokeSuite : IO UInt32 := do | none => (candidate, path?) else (candidate, path?) let tamperedPath := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx - structuralInput leftProof.toBytes rightProof.toBytes recursionVk + structuralInput leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes structuralClaimBytes allowed preimagesBlob structuralTreesBlob (MultiStark.joinPathsBlob tamperedPathAdvice) @@ -647,7 +653,7 @@ def joinSmokeSuite : IO UInt32 := do let droppedPathAdvice := structuralPathAdvice.filter fun (candidate, _) => candidate != d let droppedAssumption := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx - structuralInput leftProof.toBytes rightProof.toBytes recursionVk + structuralInput leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes structuralClaimBytes allowed preimagesBlob structuralTreesBlob (MultiStark.joinPathsBlob droppedPathAdvice) @@ -663,7 +669,7 @@ def joinSmokeSuite : IO UInt32 := do (MultiStark.CheckEnvTrees.structuralPathAdvice leftStatement rightStatement missingCarriedOutput) let missingCarried := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx - missingCarriedInput leftProof.toBytes rightProof.toBytes recursionVk + missingCarriedInput leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes missingCarriedBytes allowed preimagesBlob missingCarriedTrees missingCarriedPaths @@ -671,7 +677,7 @@ def joinSmokeSuite : IO UInt32 := do let oldAllowed := allowed.extract 0 88 let oldAllowedInput := MultiStark.joinPubInput oldAllowed structuralClaimBytes let oldAllowedRejected := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx - oldAllowedInput leftProof.toBytes rightProof.toBytes recursionVk + oldAllowedInput leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes structuralClaimBytes oldAllowed preimagesBlob structuralTreesBlob structuralPathsBlob @@ -686,8 +692,12 @@ def joinSmokeSuite : IO UInt32 := do 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 joinChildProof.toBytes) + |>.extend 0 zeroKey (bytesAsGs joinChildProofAdvice) |>.extend 2 zeroKey (bytesAsGs joinChildOuterBytes) let transitiveJoin := compiled.bytecode.execute joinIdx pubInput joinChildIo @@ -697,8 +707,12 @@ def joinSmokeSuite : IO UInt32 := do 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 wrongJoinProof.toBytes) + |>.extend 0 zeroKey (bytesAsGs wrongJoinProofAdvice) |>.extend 2 zeroKey (bytesAsGs wrongJoinOuterBytes) let wrongTransitiveAllowed := compiled.bytecode.execute joinIdx pubInput wrongJoinIo @@ -715,6 +729,11 @@ def joinSmokeSuite : IO UInt32 := do 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. @@ -731,8 +750,8 @@ def joinSmokeSuite : IO UInt32 := do (MultiStark.CheckEnvTrees.structuralPathAdvice structuralOutput rightStatement structuralParentOutput) let transitiveStructural := compiled.bytecode.executeMultiStarkJoin - structuralJoinIdx structuralParentInput structuralChildProof.toBytes - rightProof.toBytes recursionVk structuralChildOuterBytes rightOuterBytes + structuralJoinIdx structuralParentInput structuralChildProofAdvice + rightProofAdvice recursionVk structuralChildOuterBytes rightOuterBytes structuralParentBytes allowed structuralParentPreimages structuralParentTrees structuralParentPaths @@ -746,7 +765,7 @@ def joinSmokeSuite : IO UInt32 := do (MultiStark.CheckEnvTrees.adviceTrees structuralOutput rightStatement flatAboveStructuralOutput) let flatAboveStructural := compiled.bytecode.executeMultiStarkJoin joinIdx - flatAboveStructuralInput structuralChildProof.toBytes rightProof.toBytes + flatAboveStructuralInput structuralChildProofAdvice rightProofAdvice recursionVk structuralChildOuterBytes rightOuterBytes flatAboveStructuralBytes allowed structuralParentPreimages flatAboveStructuralTrees emptyPathsBlob @@ -780,8 +799,8 @@ def joinSmokeSuite : IO UInt32 := do (io.extend 2 twoKey (bytesAsGs unsortedBytes)) unsortedSubjects let unsorted := compiled.bytecode.execute joinIdx unsortedInput unsortedIo - let badLeftProofBytes := leftProof.toBytes.set! 0 - (UInt8.ofNat ((leftProof.toBytes.data[0]!.toNat + 1) % 256)) + 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 diff --git a/Tests/MultiStarkActivation.lean b/Tests/MultiStarkActivation.lean index ec685a067..a445a13c7 100644 --- a/Tests/MultiStarkActivation.lean +++ b/Tests/MultiStarkActivation.lean @@ -141,7 +141,7 @@ private structure PreparedChild where private def prepareChild (system : Aiur.AiurSystem) (indices : Indices) (config : HeightConfig) (kind : ChildKind) - (statement : MultiStark.CheckEnvTrees) : PreparedChild := + (statement : MultiStark.CheckEnvTrees) : Except String PreparedChild := do let claimBytes := Ix.Claim.ser statement.claim match kind with | .lift => @@ -150,9 +150,12 @@ private def prepareChild (system : Aiur.AiurSystem) (indices : Indices) let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] let input := MultiStark.verifierPubInput config.fakeIxvmVk innerClaimsBytes let (outer, proof, _) := system.prove indices.lift input default - { proofBytes := proof.toBytes + let adviceBytes ← system.proofToAdviceBytes outer proof + pure ({ + proofBytes := adviceBytes outerClaimsBytes := MultiStark.serializeClaims #[outer] - preimages := #[innerClaimsBytes, claimBytes] } + preimages := #[innerClaimsBytes, claimBytes] + } : PreparedChild) | .flat | .structural => let idx := match kind with | .flat => indices.flat @@ -160,9 +163,12 @@ private def prepareChild (system : Aiur.AiurSystem) (indices : Indices) | .lift => unreachable! let input := MultiStark.joinPubInput config.allowed claimBytes let (outer, proof, _) := system.prove idx input default - { proofBytes := proof.toBytes + let adviceBytes ← system.proofToAdviceBytes outer proof + pure ({ + proofBytes := adviceBytes outerClaimsBytes := MultiStark.serializeClaims #[outer] - preimages := #[claimBytes] } + preimages := #[claimBytes] + } : PreparedChild) private structure JoinCase where label : String @@ -192,7 +198,7 @@ The right child remains a lift. Both child positions call the same decoder, so varying one side covers all three decoder arms while retaining a mixed-shape case for the flat and structural child kinds. -/ private def prepareJoinCases (system : Aiur.AiurSystem) (indices : Indices) - (configs : Array HeightConfig) : Array JoinCase := Id.run do + (configs : Array HeightConfig) : Except String (Array JoinCase) := do let a := Address.blake3 "activation-subject-left".toUTF8 let b := Address.blake3 "activation-subject-right".toUTF8 let c := Address.blake3 "activation-carry-left".toUTF8 @@ -220,9 +226,9 @@ private def prepareJoinCases (system : Aiur.AiurSystem) (indices : Indices) leftAsm disposition let right := selectStatement rightNone rightDischarge rightCarry rightAsm disposition - let rightChild := prepareChild system indices config .lift right + let rightChild ← prepareChild system indices config .lift right for childKind in #[ChildKind.lift, .flat, .structural] do - let leftChild := prepareChild system indices config childKind left + let leftChild ← prepareChild system indices config childKind left cases := cases.push { label := s!"height={config.height.label},left-asm={assumptionLabel leftAsm},\ right-asm={assumptionLabel rightAsm},disposition={disposition.label},\ @@ -246,10 +252,11 @@ private def runLift (compiled : Aiur.CompiledToplevel) Except String Sample := do let input := MultiStark.digestGs config.fakeIxvmVk let (innerClaim, proof, _) := childSystem.prove indices.verify input default + let proofBytes ← childSystem.proofToAdviceBytes innerClaim proof let claimBytes := MultiStark.serializeClaims #[innerClaim] let pubInput := MultiStark.verifierPubInput childVk claimBytes let (_, queryCounts) ← compiled.bytecode.executeMultiStark productionLiftIdx - pubInput proof.toBytes childVk claimBytes + pubInput proofBytes childVk claimBytes pure { label := s!"lift/height={config.height.label}" entrypoint := .lift @@ -471,7 +478,9 @@ def run : IO UInt32 := do ({short.probeRows} vs {tall.probeRows} rows)" return 1 let configs := #[short, tall] - let cases := prepareJoinCases childSystem indices configs + let cases ← match prepareJoinCases childSystem indices configs with + | .error e => IO.eprintln s!"activation audit input preparation failed: {e}"; return 1 + | .ok cases => pure cases if cases.size != 48 then IO.eprintln s!"activation audit: expected 48 join cases, built {cases.size}" return 1 diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 06ed9643b..4f9ab028c 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -1001,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: @@ -1084,8 +1086,9 @@ fn build_multi_stark_join_io_buffer( })) } -/// `Bytecode.Toplevel.executeMultiStarkJoin`: execute either join entrypoint over raw -/// proof/claim/tree/path blobs. The native builder expands the compact keyed +/// `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. @@ -1147,7 +1150,9 @@ extern "C" fn rs_aiur_multi_stark_join_execute( } /// `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. 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/ixvm-codegen/src/aiur_multi_stark_runner.rs b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs index 52f6ee7d0..98c48731c 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs @@ -188,10 +188,10 @@ fn index_key(index: u8) -> Vec { #[inline] fn packed_digest_key(digest: &[u8; 32]) -> Vec { digest - .chunks_exact(4) - .map(|word| { - G::from_u32(u32::from_le_bytes(word.try_into().expect("four-byte chunk"))) - }) + .as_chunks::<4>() + .0 + .iter() + .map(|word| G::from_u32(u32::from_le_bytes(*word))) .collect() } diff --git a/docs/benchmarking.md b/docs/benchmarking.md index a30e93ca5..e5a566412 100644 --- a/docs/benchmarking.md +++ b/docs/benchmarking.md @@ -116,12 +116,27 @@ 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. WP-E2 measures its proof-size delta against this value. - -The box-independent `--queries 0` join wiring gate produced a 246,014-byte -flat-join proof, 10,280,903,348 FFT cost, 6.57 s prove time, 10,798,899,200-byte -peak RSS, and 1.44 ms native verification. Those are smoke values, not W0 cost -estimates; the q=50 join run remains a large-box benchmark. +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 From 33c618df1cae36844200658a59c07ef15a3d563e Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Fri, 28 Aug 2026 17:06:47 -0700 Subject: [PATCH 22/44] feat: ixAggr heterogeneous recursive aggregation toplevel MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add Ix/Aggr, a recursive aggregation system for IxVM shard proofs that keeps Ix/MultiStark untouched and Ix-agnostic. One entrypoint, ix_aggr, subsumes lifting and joining: a one-byte advice shape selects wrap or binary join over any mix of IxVM and ix_aggr children, so shard proofs enter the recursion system directly as join children and the dedicated lift stage disappears. Circuit (Ix/Aggr/Circuit.lean): every shape verifies its children in full (verify + ood_verify from the shared Multi-STARK verifier modules) against the vk its hinted kind demands. Identity is one 80-byte digest-bound blob - blake3(ixvm vk) || verify_claim idx || blake3(self vk) || ix_aggr idx - carried unchanged at every node; self children must bind the identical blob digest, pinning both vks and both entrypoint indices transitively. Claims are a uniform 18-word [0, aggr_idx, allowed(8), checkEnv(8)] at every depth, so proofs of different tree levels combine freely. Wrap shapes bind the output digest to the child CheckEnv digest directly; pair shapes open both CheckEnv preimages, re-root the canonical subject/assumption trees, and prove subjects = L ∪ R, assumptions = (asmL ∪ asmR) ∖ subjects with linear sorted merges. Toplevel (Ix/Aggr.lean): ixAggr = MultiStark.multiStarkFull + circuit, pruned to ix_aggr, so verify_multi_stark_proof and other unrelated entries no longer pad aggregate proofs. The host half of the wire contracts (allowed blob, public input packing, shape codes, keyed preimage/tree blob framing, interpreter IO assembly) lives beside the toplevel; Ix/Aggr/Host.lean folds CheckEnvTrees statements. Native path: ix codegen gains the ix-aggr target (crates/ixvm-codegen/src/aiur_ix_aggr.rs, 244 fns); its runner builds the seven-channel IO buffer natively and routes execution through the generated code. New FFI rs_aiur_ix_aggr_execute/_prove (executeIxAggr/proveIxAggr) pass proofs, vks, claims, and the compact count/key/length preimage/tree blobs without per-byte boxing, plus Proof.ofBytesChecked for store-boundary decoding. CLI: ix aggr --ixe E --ixes M ... reconstructs every nonempty shard statement from the env, matches wrappers by claim digest, natively pre-verifies them, folds a balanced bisection (the canonical fold makes the root claim independent of tree shape), wraps single-shard roots so the persisted root is always an ix_aggr proof, checks the root closes over the env canonical tree with no residual assumptions, and persists the wrapper. Tests (lake test -- ix-aggr, 17 cases): all five shapes accept over real Multi-STARK stand-in child proofs from two distinct-vk systems; codegen'd execution matches the interpreter on output and per-circuit query counts for wrap and pair; negatives break one binding each - lying shape hint, tampered proof, foreign identity, wrap statement drift, dropped assumption, padded subject set, and tree advice not reproducing its keyed root. --- Ix/Aggr.lean | 181 + Ix/Aggr/Circuit.lean | 673 + Ix/Aggr/Host.lean | 101 + Ix/Aiur/Protocol.lean | 21 +- Ix/Aiur/Semantics/BytecodeFfi.lean | 19 + Ix/Cli/AggrCmd.lean | 353 + Ix/Cli/CodegenCmd.lean | 14 +- Main.lean | 2 + Tests/Aggr.lean | 291 + Tests/Main.lean | 4 + crates/ffi/src/aiur/protocol.rs | 158 + crates/ixvm-codegen/src/aiur_ix_aggr.rs | 25101 ++++++++++++++++ .../ixvm-codegen/src/aiur_ix_aggr_runner.rs | 329 + crates/ixvm-codegen/src/lib.rs | 2 + 14 files changed, 27244 insertions(+), 5 deletions(-) create mode 100644 Ix/Aggr.lean create mode 100644 Ix/Aggr/Circuit.lean create mode 100644 Ix/Aggr/Host.lean create mode 100644 Ix/Cli/AggrCmd.lean create mode 100644 Tests/Aggr.lean create mode 100644 crates/ixvm-codegen/src/aiur_ix_aggr.rs create mode 100644 crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs diff --git a/Ix/Aggr.lean b/Ix/Aggr.lean new file mode 100644 index 000000000..878bd4ab1 --- /dev/null +++ b/Ix/Aggr.lean @@ -0,0 +1,181 @@ +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 the verified form: `0`/`1` wrap one IxVM / +`ix_aggr` child; `2`–`5` fold a 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 + +/-! ## 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) + +/-! ## 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)) + +/-- 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..e76c874e2 --- /dev/null +++ b/Ix/Aggr/Circuit.lean @@ -0,0 +1,673 @@ +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 lifting and joining. A non-deterministic +shape hint (IO channel 6) selects one of five 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 | + +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. 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`. + +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]` | one shape byte (0–5) | +-/ + +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), + }, + } + } + + 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); + () + } + + /- ## 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 = (IxVM, IxVM) 3 = (IxVM, self) + -- 4 = (self, IxVM) 5 = (self, self) + 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), + } + } +⟧ + +end Aggr + +end diff --git a/Ix/Aggr/Host.lean b/Ix/Aggr/Host.lean new file mode 100644 index 000000000..aae894521 --- /dev/null +++ b/Ix/Aggr/Host.lean @@ -0,0 +1,101 @@ +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. These helpers give +the CLI, tests, and benchmarks one implementation for constructing fold +outputs plus their channel-5 advice. +-/ + +public section + +namespace Aggr + +/-- A `CheckEnv` statement together with the canonical trees whose roots it +commits to. `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 assumption-candidate stream of a pair fold: +`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 } + +/-- 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 + +end CheckEnvTrees + +end Aggr + +end diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 3f8311918..1ffd3178b 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -25,12 +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. Cache +/-- 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 @@ -179,6 +178,24 @@ opaque proveMultiStarkJoin (system : @& AiurSystem) (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 blobs are produced by +`Aggr.preimagesBlob` and `Aggr.treesBlob`; wrap 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 : @& 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 → diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index 564c49513..af11293e1 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -193,6 +193,25 @@ opaque executeMultiStarkJoin (toplevel : @& Bytecode.Toplevel) (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` and `treesBlob` use the compact +count/key/length framing produced by `Aggr.preimagesBlob` and +`Aggr.treesBlob`. Rust expands them directly into IO channels 0–6 (the +shape hint lands on channel 6). Wrap shapes pass empty right-child 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 : @& ByteArray) (useBytecode : Bool := false) : + Except String (Array G × Array QueryCount) + -- (EnvHandle opaque type + constructors live above `namespace -- Bytecode.Toplevel`; see `Aiur.EnvHandle`. The with-env FFI -- declarations below reference `EnvHandle` and `Bytecode.Toplevel` diff --git a/Ix/Cli/AggrCmd.lean b/Ix/Cli/AggrCmd.lean new file mode 100644 index 000000000..046e2d344 --- /dev/null +++ b/Ix/Cli/AggrCmd.lean @@ -0,0 +1,353 @@ +/- + `ix aggr --ixe E --ixes M ...` + + Fold persisted IxVM shard proofs into one recursive `ix_aggr` proof of the + whole environment. There is no lift stage: shard proofs enter the recursion + system directly as `ix_aggr` join children, and the tree is a balanced + bisection over the manifest's nonempty shards. Because the statement fold is + canonical (sorted-set union/difference), the root claim is independent of + the fold order; a single-shard environment is closed with one wrap so the + persisted root is always an `ix_aggr` proof. + + This first host driver is intentionally serial and cache-free. Its slot + model and content-addressed inputs make parallel scheduling and resumable + cache entries follow-up optimizations rather than protocol changes. +-/ +module +public import Cli +public import Ix.Aggr +public import Ix.Cli.CheckCmd +public import Ix.IxVM +public import Ix.IxVM.ClaimHarness +public import Ix.Store + +public section + +namespace Ix.Cli.AggrCmd + +structure PreparedShard where + claim : Ix.Claim + statement : Aggr.CheckEnvTrees + +/-- One aggregation slot: either a raw shard proof (`kind = .ixvm`, the +IxVM `verify_claim` wrapper) or an `ix_aggr` output (`kind = .aggr`). Proofs +stay compact as `Aiur.Proof` values between folds and are expanded only at a +recursive advice boundary. `claimsBytes` are the serialized claims a parent +feeds to IO channel 2. -/ +structure Slot where + kind : Aggr.ChildKind + statement : Aggr.CheckEnvTrees + outerClaim : Array Aiur.G + proof : Aiur.Proof + claimsBytes : ByteArray + +/-- Everything a fold step needs, resolved once before proving. -/ +structure Backend where + ixvmSystem : Aiur.AiurSystem + aggrSystem : Aiur.AiurSystem + aggrIdx : Aiur.Bytecode.FunIdx + ixvmVk : ByteArray + aggrVk : ByteArray + allowed : ByteArray + +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 ← Aggr.CheckEnvTrees.ofClaim claim trees + pure { claim, statement } + +private def compileToplevel (label : String) + (source : Except Aiur.Global Aiur.Source.Toplevel) : + Except String Aiur.CompiledToplevel := do + match source with + | .error e => throw s!"{label} toplevel merge failed: {e}" + | .ok top => match top.compile with + | .error e => throw s!"{label} compilation failed: {e}" + | .ok compiled => pure compiled + +/-- The serialized `verify_claim` claims of one shard wrapper — what the +IxVM prover's Fiat-Shamir transcript observed, and what a parent decodes. -/ +private def shardClaimsBytes (verifyIdx : Aiur.Bytecode.FunIdx) + (claim : Ix.Claim) : ByteArray := + let digestKey := IxVM.ClaimHarness.packedDigestKey + (Address.blake3 (Ix.Claim.ser claim)) + MultiStark.serializeClaims #[Aiur.buildClaim verifyIdx digestKey #[]] + +private def kindLabel : Aggr.ChildKind → String + | .ixvm => "shard" + | .aggr => "fold" + +/-- Expand one compact child proof into the per-query transport consumed by +the recursive verifier. The child kind selects the verifying system whose +wire codec must be used. -/ +private def proofAdviceBytes (backend : Backend) (slot : Slot) : + Except String ByteArray := + let system := match slot.kind with + | .ixvm => backend.ixvmSystem + | .aggr => backend.aggrSystem + system.proofToAdviceBytes slot.outerClaim slot.proof + +/-- Prove one pair fold and natively verify its output. -/ +private def proveJoin (backend : Backend) (left right : Slot) : + IO (Except String Slot) := do + let output := left.statement.join right.statement + let outputClaimBytes := Ix.Claim.ser output.claim + let shape := Aggr.shapeCode (left.kind, some right.kind) + let pubInput := Aggr.pubInput backend.allowed outputClaimBytes + let preimages := Aggr.preimagesBlob + #[Ix.Claim.ser left.statement.claim, Ix.Claim.ser right.statement.claim] + let trees := Aggr.treesBlob + (Aggr.CheckEnvTrees.adviceTrees left.statement right.statement output) + IO.println s!"[aggr] folding {kindLabel left.kind} + {kindLabel right.kind} \ + ({output.subjectCount} subjects)" + (← IO.getStdout).flush + let leftProofAdvice ← match proofAdviceBytes backend left with + | .error e => return .error s!"left {kindLabel left.kind} proof advice encoding failed: {e}" + | .ok bytes => pure bytes + let rightProofAdvice ← match proofAdviceBytes backend right with + | .error e => return .error s!"right {kindLabel right.kind} proof advice encoding failed: {e}" + | .ok bytes => pure bytes + let result := backend.aggrSystem.proveIxAggr backend.aggrIdx pubInput shape + leftProofAdvice rightProofAdvice backend.ixvmVk backend.aggrVk + left.claimsBytes right.claimsBytes outputClaimBytes backend.allowed + preimages trees + let (outerClaim, proof) ← match result with + | .error e => return .error s!"fold proving failed: {e}" + | .ok result => pure result + match backend.aggrSystem.verify outerClaim proof with + | .error e => return .error s!"fold output failed native verification: {e}" + | .ok () => pure () + return .ok { + kind := .aggr + statement := output + outerClaim + proof + claimsBytes := MultiStark.serializeClaims #[outerClaim] + } + +/-- Prove one wrap of an IxVM shard slot (single-shard environments), so the +persisted root is always an `ix_aggr` proof. -/ +private def proveWrap (backend : Backend) (child : Slot) : + IO (Except String Slot) := do + let outputClaimBytes := Ix.Claim.ser child.statement.claim + let shape := Aggr.shapeCode (child.kind, none) + let pubInput := Aggr.pubInput backend.allowed outputClaimBytes + IO.println s!"[aggr] wrapping single {kindLabel child.kind}" + (← IO.getStdout).flush + let childProofAdvice ← match proofAdviceBytes backend child with + | .error e => return .error s!"{kindLabel child.kind} proof advice encoding failed: {e}" + | .ok bytes => pure bytes + let result := backend.aggrSystem.proveIxAggr backend.aggrIdx pubInput shape + childProofAdvice ByteArray.empty backend.ixvmVk backend.aggrVk + child.claimsBytes ByteArray.empty outputClaimBytes backend.allowed + (Aggr.preimagesBlob #[]) (Aggr.treesBlob #[]) + let (outerClaim, proof) ← match result with + | .error e => return .error s!"wrap proving failed: {e}" + | .ok result => pure result + match backend.aggrSystem.verify outerClaim proof with + | .error e => return .error s!"wrap output failed native verification: {e}" + | .ok () => pure () + return .ok { + kind := .aggr + statement := child.statement + outerClaim + proof + claimsBytes := MultiStark.serializeClaims #[outerClaim] + } + +/-- Balanced bisection fold over `slots[lo:hi]`. Canonical set folds make the +root claim independent of this shape; balance minimizes depth. -/ +private partial def foldRange (backend : Backend) (slots : Array Slot) + (lo hi : Nat) : IO (Except String Slot) := do + if hi - lo == 1 then + let some slot := slots[lo]? + | return .error s!"internal: fold range references missing slot {lo}" + return .ok slot + let mid := lo + (hi - lo) / 2 + let left ← match ← foldRange backend slots lo mid with + | .error e => return .error e + | .ok slot => pure slot + let right ← match ← foldRange backend slots mid hi with + | .error e => return .error e + | .ok slot => pure slot + proveJoin backend left right + +def runAggrCmd (p : Cli.Parsed) : IO UInt32 := do + let some ixePath := (p.flag? "ixe").map (·.as! String) | do + p.printError "error: aggr requires --ixe " + return 1 + let some manifestPath := (p.flag? "ixes").map (·.as! String) | do + p.printError "error: aggr requires --ixes " + return 1 + + 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 allShards ← match Ix.Cli.CheckCmd.parseIxesAllShards + (← IO.FS.readBinFile manifestPath) with + | .error e => IO.eprintln s!"manifest parse failed: {e}"; return 1 + | .ok shards => pure shards + if !(← Ix.Cli.CheckCmd.shardsCover env allShards) then return 1 + + -- Reconstruct every nonempty shard's statement from the environment once. + -- This binds proof wrappers to shards and supplies canonical fold advice. + let mut prepared : Array (Nat × PreparedShard) := #[] + let mut digestToSlot : Std.HashMap Address Nat := {} + for (blocks, shard) in allShards.mapIdx fun shard blocks => (blocks, shard) do + if (Ix.Cli.CheckCmd.ownedConstsForBlocks env blocks).isEmpty then + IO.println s!"[aggr] skipping zero-constant manifest shard {shard}" + continue + let item ← match prepareShard env blocks with + | .error e => IO.eprintln s!"prepare shard {shard}: {e}"; return 1 + | .ok item => pure item + let digest := Address.blake3 (Ix.Claim.ser item.claim) + if digestToSlot.contains digest then + IO.eprintln s!"duplicate reconstructed shard claim digest {digest} \ + (manifest shard {shard})" + return 1 + digestToSlot := digestToSlot.insert digest prepared.size + prepared := prepared.push (shard, item) + if prepared.isEmpty then + IO.eprintln "manifest contains no nonempty shard" + return 1 + + let depth := Nat.log2 (2 * prepared.size - 1) + let wrapNote := if prepared.size == 1 then " + 1 wrap" else "" + IO.println s!"[aggr] plan: {prepared.size} shard leaves, \ + {prepared.size - 1} pair folds{wrapNote} (balanced bisection, depth {depth})" + if p.hasFlag "plan-only" then return 0 + + let proofHexes := (p.variableArgsAs! String).toList + if proofHexes.length != prepared.size then + IO.eprintln s!"aggr requires exactly {prepared.size} shard proofs; \ + got {proofHexes.length}" + return 1 + + -- Proof arguments may be in any order. Match them by their bundled claim + -- and reject duplicates/collisions before starting expensive proving. + let mut proofsBySlot : 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 slot := digestToSlot.get? digest | do + IO.eprintln s!"proof {proofAddress} claim {digest} matches no manifest shard" + return 1 + let some (shard, expected) := prepared[slot]? | do + IO.eprintln s!"internal: missing prepared slot {slot}" + return 1 + if wrapper.claim != expected.claim then + IO.eprintln s!"proof {proofAddress} hit a claim-digest collision for shard {shard}" + return 1 + if proofsBySlot.contains slot then + IO.eprintln s!"more than one proof supplied for shard {shard}" + return 1 + proofsBySlot := proofsBySlot.insert slot wrapper + if proofsBySlot.size != prepared.size then + IO.eprintln "not every nonempty 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" 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 := Aiur.AiurSystem.build aggrCompiled.bytecode + Aiur.defaultCommitmentParameters Aiur.defaultFriParameters + let ixvmVk := ixvmSystem.vkBytes + let aggrVk := aggrSystem.vkBytes + let backend : Backend := { + ixvmSystem, aggrSystem, aggrIdx, ixvmVk, aggrVk + allowed := Aggr.allowedBlob ixvmVk verifyIdx aggrVk aggrIdx + } + + -- Natively pre-verify every shard proof before any expensive fold, and + -- decode proof bytes through the checked constructor: wrappers come from + -- the store, an untrusted boundary. + let mut slots : Array Slot := #[] + for (item, slot) in prepared.mapIdx fun slot item => (item, slot) do + let (shard, preparedShard) := item + let some wrapper := proofsBySlot.get? slot | do + IO.eprintln s!"internal: no proof for shard {shard}" + return 1 + let proof ← match Aiur.Proof.ofBytesChecked wrapper.proof with + | .error e => IO.eprintln s!"shard {shard} proof decode failed: {e}"; return 1 + | .ok proof => pure proof + let digestKey := IxVM.ClaimHarness.packedDigestKey + (Address.blake3 (Ix.Claim.ser preparedShard.claim)) + let innerClaim := Aiur.buildClaim verifyIdx digestKey #[] + match ixvmSystem.verify innerClaim proof with + | .error e => + IO.eprintln s!"shard {shard} proof fails native verification: {e}" + return 1 + | .ok () => pure () + slots := slots.push { + kind := .ixvm + statement := preparedShard.statement + outerClaim := innerClaim + proof + claimsBytes := shardClaimsBytes verifyIdx preparedShard.claim + } + + let folded ← match ← foldRange backend slots 0 slots.size with + | .error e => IO.eprintln e; return 1 + | .ok slot => pure slot + -- A single-shard environment still gets an `ix_aggr` root via one wrap. + let root ← match folded.kind with + | .aggr => pure folded + | .ixvm => match ← proveWrap backend folded with + | .error e => IO.eprintln e; return 1 + | .ok slot => pure slot + + let some envTree := IxVM.ClaimHarness.envCanonicalTree env | do + IO.eprintln "cannot aggregate an empty environment" + return 1 + if root.statement.subjects.root != envTree.root then + IO.eprintln s!"aggregate root subjects are {root.statement.subjects.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 + + let claim := root.statement.claim + let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) + let wrapper : Ixon.Proof := { claim, proof := root.proof.toBytes } + let proofAddress ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) + IO.println s!"[aggr] root proof: {proofAddress}" + return 0 + +end Ix.Cli.AggrCmd + +open Ix.Cli.AggrCmd in +def aggrCmd : Cli.Cmd := `[Cli| + aggr VIA runAggrCmd; + "Fold IxVM shard proofs into one recursive ix_aggr proof of the whole environment" + + FLAGS: + "ixe" : String; "Path to the serialized environment whose shards were proven." + "ixes" : String; "Path to the shard manifest defining the shard partition." + "plan-only"; "Validate coverage and print the fold plan without loading or proving shard proofs." + + 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/CodegenCmd.lean b/Ix/Cli/CodegenCmd.lean index f958c4bee..608f837c4 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 aggr` 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 diff --git a/Main.lean b/Main.lean index 6963f1ad3..f6cc3b0e1 100644 --- a/Main.lean +++ b/Main.lean @@ -1,6 +1,7 @@ --import Ix.Cli.StoreCmd import Ix.Cli.AddrOfCmd import Ix.Cli.AggregateCmd +import Ix.Cli.AggrCmd import Ix.Cli.BenchReport import Ix.Cli.CheckCmd import Ix.Cli.CodegenCmd @@ -35,6 +36,7 @@ def ixCmd : Cli.Cmd := `[Cli| SUBCOMMANDS: --storeCmd; + aggrCmd; benchCmd; aggregateCmd; catalogCmd; diff --git a/Tests/Aggr.lean b/Tests/Aggr.lean new file mode 100644 index 000000000..ba1402198 --- /dev/null +++ b/Tests/Aggr.lean @@ -0,0 +1,291 @@ +module + +public import LSpec +public import Ix.Aggr +public import Ix.Claim +public import Ix.AssumptionTree +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 five 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, and the canonical union/difference fold. +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 := #[]) : 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 + 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 + + -- ── 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 run (shape : Nat) (children : Array ChildSlot) (outBytes : ByteArray) + (outClaim? : Option ByteArray := none) + (preimages : Array ByteArray := #[]) + (trees : Array Ix.AssumptionTree := #[]) := + aggrCompiled.bytecode.execute ixAggrIdx (Aggr.pubInput allowed outBytes) + (mkIO allowed shape ixvmVk aggrVk children outClaim? preimages trees) + 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) + + 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 + + -- ── 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) + 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 #[]) + + -- ── 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 + + 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]), + 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, + test "codegen'd pair matches interpreter (output + query counts)" + (sameCounts nativePair pairII), + test "codegen'd wrap matches interpreter (output + query counts)" + (sameCounts nativeWrap wrapIxvm), + 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, + ])]) [] + +end Tests.Aggr + +end diff --git a/Tests/Main.lean b/Tests/Main.lean index 15e7eb94a..134e2f560 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -54,6 +54,7 @@ import Tests.FFI import Tests.Keccak import Tests.MultiStark import Tests.MultiStarkActivation +import Tests.Aggr import Tests.Cli import Tests.ShardMap import Tests.Ix.EnvBody @@ -186,6 +187,9 @@ def primaryRunners : List (String × IO UInt32) := [ ("multi-stark", Tests.MultiStark.selfTestSuite), ("recursive-verifier", Tests.MultiStark.endToEndSuite), ("aggregate-first", Tests.MultiStark.joinSmokeSuite), + -- Heterogeneous aggregation circuit: all five `ix_aggr` shapes over + -- stand-in child systems, plus one negative case per broken binding. + ("ix-aggr", Tests.Aggr.smokeSuite), ] /-- Ignored test runners - expensive, deferred IO actions run only when explicitly requested -/ diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 4f9ab028c..093db49eb 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -1249,6 +1249,164 @@ extern "C" fn rs_aiur_multi_stark_join_prove( 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], +) -> Result { + use ixvm_codegen::aiur_ix_aggr_runner::{ + AggrAdvice, aggr_io_buffer, 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)?; + 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, + })) +} + +/// `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>, + fun_idx: LeanNat>, + pub_input: LeanArray>, + shape: LeanNat>, + left_proof_advice_bytes: LeanByteArray>, + right_proof_advice_bytes: LeanByteArray>, + ixvm_vk_bytes: LeanByteArray>, + self_vk_bytes: LeanByteArray>, + left_claims_bytes: LeanByteArray>, + right_claims_bytes: LeanByteArray>, + output_claim_bytes: LeanByteArray>, + allowed_bytes: LeanByteArray>, + preimages_blob: LeanByteArray>, + trees_blob: LeanByteArray>, + use_bytecode: bool, +) -> LeanExcept { + 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(), + ) { + 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>, + fun_idx: LeanNat>, + pub_input: LeanArray>, + shape: LeanNat>, + left_proof_advice_bytes: LeanByteArray>, + right_proof_advice_bytes: LeanByteArray>, + ixvm_vk_bytes: LeanByteArray>, + self_vk_bytes: LeanByteArray>, + left_claims_bytes: LeanByteArray>, + right_claims_bytes: LeanByteArray>, + output_claim_bytes: LeanByteArray>, + allowed_bytes: LeanByteArray>, + preimages_blob: LeanByteArray>, + trees_blob: LeanByteArray>, + use_bytecode: bool, +) -> LeanExcept { + 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(), + ) { + 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/ixvm-codegen/src/aiur_ix_aggr.rs b/crates/ixvm-codegen/src/aiur_ix_aggr.rs new file mode 100644 index 000000000..df574bfeb --- /dev/null +++ b/crates/ixvm-codegen/src/aiur_ix_aggr.rs @@ -0,0 +1,25101 @@ +// 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_228] = { let __args: [G; IN_228] = [__v_0]; 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 __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_228] = { let __args: [G; IN_228] = [__v_0]; 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 __v_73: G = __r_arr[0]; + let __v_74: G = (__v_73 * __v_7); + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; 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 __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_232] = { let __args: [G; IN_232] = [__v_87, __v_155]; 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_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_227] = { let __args: [G; IN_227] = [__v_0, __v_10]; 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 __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_227] = { let __args: [G; IN_227] = [__v_0, __v_3]; 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 __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_234] = { let __args: [G; IN_234] = [__v_2, __v_10]; 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_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_236] = { let __args: [G; IN_236] = [__v_6]; 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_40: G = __r_arr[0]; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__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_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_227] = { let __args: [G; IN_227] = [__v_8, __v_11]; 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 __v_12: G = __r_arr[0]; + let __v_13: G = G::from_u64(1); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_8, __v_13]; 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 __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_227] = { let __args: [G; IN_227] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = (__v_13 + __v_3); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __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_227] = { let __args: [G; IN_227] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = (__v_13 + __v_3); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_16, __v_17]; 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 __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_229] = { let __args: [G; IN_229] = [__v_8, __v_4]; 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 __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_227] = { let __args: [G; IN_227] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = (__v_17 + __v_3); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_11, __v_6]; 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 __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_12, __v_6]; 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 __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_229] = { let __args: [G; IN_229] = [__v_1, __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 __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_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_21: G = __r_arr[0]; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __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_234] = { let __args: [G; IN_234] = [__v_8, __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_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_227] = { let __args: [G; IN_227] = [__v_0, __v_3]; 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 __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_229] = { let __args: [G; IN_229] = [__v_2, __v_4]; 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 __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_227] = { let __args: [G; IN_227] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __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_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_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_229] = { let __args: [G; IN_229] = [__v_11, __v_26]; 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 __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_231] = { let __args: [G; IN_231] = [__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_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_229] = { let __args: [G; IN_229] = [__v_1, __v_28]; 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 __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_229] = { let __args: [G; IN_229] = [__v_1, __v_33]; 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 __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_229] = { let __args: [G; IN_229] = [__v_1, __v_38]; 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 __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_229] = { let __args: [G; IN_229] = [__v_23, __v_54]; 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 __v_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __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_231] = { let __args: [G; IN_231] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __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_239] = { let __args: [G; IN_239] = [__v_29]; 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_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_239] = { let __args: [G; IN_239] = [__v_34]; 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_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_239] = { let __args: [G; IN_239] = [__v_39]; 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_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_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_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_233] = { let __args: [G; IN_233] = [__v_0, __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 = 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_233] = { let __args: [G; IN_233] = [__v_104, __v_108]; 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_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_236] = { let __args: [G; IN_236] = [__v_7]; 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_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_231] = { let __args: [G; IN_231] = [__v_8]; 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_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_231] = { let __args: [G; IN_231] = [__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_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 = 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 = 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 = 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 = 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_233] = { let __args: [G; IN_233] = [__v_0, __v_12]; 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_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_233] = { let __args: [G; IN_233] = [__v_0, __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 __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_233] = { let __args: [G; IN_233] = [__v_75, __v_81]; 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_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_233] = { let __args: [G; IN_233] = [__v_102, __v_108]; 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_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_233] = { let __args: [G; IN_233] = [__v_110, __v_114]; 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_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_231] = { let __args: [G; IN_231] = [__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_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_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_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_239] = { let __args: [G; IN_239] = [__v_22]; 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_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_239] = { let __args: [G; IN_239] = [__v_18]; 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_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_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_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_229] = { let __args: [G; IN_229] = [__v_4, __v_18]; 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 __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_229] = { let __args: [G; IN_229] = [__v_5, __v_18]; 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 __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_229] = { let __args: [G; IN_229] = [__v_2, __v_18]; 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 __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_229] = { let __args: [G; IN_229] = [__v_3, __v_18]; 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 __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_229] = { let __args: [G; IN_229] = [__v_6, __v_18]; 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 __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_229] = { let __args: [G; IN_229] = [__v_7, __v_18]; 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 __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_229] = { let __args: [G; IN_229] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __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_229] = { let __args: [G; IN_229] = [__v_35, __v_89]; 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 __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_229] = { let __args: [G; IN_229] = [__v_35, __v_94]; 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 __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_229] = { let __args: [G; IN_229] = [__v_36, __v_97]; 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 __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_229] = { let __args: [G; IN_229] = [__v_36, __v_102]; 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 __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_229] = { let __args: [G; IN_229] = [__v_35, __v_91]; 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 __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_229] = { let __args: [G; IN_229] = [__v_35, __v_96]; 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 __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_229] = { let __args: [G; IN_229] = [__v_35, __v_101]; 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 __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_229] = { let __args: [G; IN_229] = [__v_35, __v_106]; 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 __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_229] = { let __args: [G; IN_229] = [__v_9, __v_82]; 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 __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_229] = { let __args: [G; IN_229] = [__v_8, __v_85]; 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 __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_229] = { let __args: [G; IN_229] = [__v_9, __v_94]; 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 __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_229] = { let __args: [G; IN_229] = [__v_8, __v_97]; 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 __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_231] = { let __args: [G; IN_231] = [__v_2]; 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_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_227] = { let __args: [G; IN_227] = [__v_1, __v_3]; 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 __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_4, __v_5]; 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 __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(1); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_4, __v_7]; 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 __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_227] = { let __args: [G; IN_227] = [__v_2, __v_9]; 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 __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_229] = { let __args: [G; IN_229] = [__v_3, __v_9]; 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 __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_4, __v_9]; 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 __v_32: G = __r_arr[0]; + let __v_33: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_32, __v_33]; 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 __v_34: G = __r_arr[0]; + let __v_35: G = G::from_u64(1); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_32, __v_35]; 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 __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_9]; 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 __v_37: G = __r_arr[0]; + let __v_38: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_37, __v_38]; 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 __v_39: G = __r_arr[0]; + let __v_40: G = G::from_u64(1); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_37, __v_40]; 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 __v_41: G = __r_arr[0]; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1, __v_9]; 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 __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_227] = { let __args: [G; IN_227] = [__v_7, __v_43]; 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 __v_44: G = __r_arr[0]; + let __v_45: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_44, __v_45]; 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 __v_46: G = __r_arr[0]; + let __v_47: G = G::from_u64(1); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_44, __v_47]; 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 __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_229] = { let __args: [G; IN_229] = [__v_41, __v_230]; 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 __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_229] = { let __args: [G; IN_229] = [__v_39, __v_233]; 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 __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_229] = { let __args: [G; IN_229] = [__v_41, __v_242]; 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 __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_229] = { let __args: [G; IN_229] = [__v_39, __v_245]; 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 __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_231] = { let __args: [G; IN_231] = [__v_25]; 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_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_227] = { let __args: [G; IN_227] = [__v_8, __v_9]; 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 __v_232: G = __r_arr[0]; + let __v_233: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_232, __v_233]; 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 __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_231] = { let __args: [G; IN_231] = [__v_235]; 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_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_233] = { let __args: [G; IN_233] = [__v_106, __v_112]; 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_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_233] = { let __args: [G; IN_233] = [__v_133, __v_139]; 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_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_233] = { let __args: [G; IN_233] = [__v_141, __v_145]; 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_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_238] = { let __args: [G; IN_238] = [__v_37]; 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_364: G = __r_arr[0]; + match __v_18.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_18]; 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_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_233] = { let __args: [G; IN_233] = [__v_188, __v_372]; 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_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_233] = { let __args: [G; IN_233] = [__v_438, __v_442]; 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_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_239] = { let __args: [G; IN_239] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __v_450: G = __r_arr[0]; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_8]; 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_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_238] = { let __args: [G; IN_238] = [__v_37]; 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_455: G = __r_arr[0]; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_16]; 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_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_236] = { let __args: [G; IN_236] = [__v_19]; 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_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_231] = { let __args: [G; IN_231] = [__v_20]; 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_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_231] = { let __args: [G; IN_231] = [__v_21]; 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_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_233] = { let __args: [G; IN_233] = [__v_3, __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_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_228] = { let __args: [G; IN_228] = [__v_40]; 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 __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 = 1; +const IN_214: usize = 1; +const OUT_214: usize = 3; +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 __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_214] = [__v_3, __v_4, __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); + }, + 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_214] = [__v_5, __v_3, __v_4]; + 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); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_215: usize = 1; +const IN_215: usize = 1; +const OUT_215: usize = 3; +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 __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_214] = { let __args: [G; IN_214] = [__v_4]; 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_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_215] = [__v_3, __v_5, __v_6]; + 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 = 8; +const IN_216: usize = 8; +const OUT_216: usize = 1; +fn aiur_fn_216( + inp: [G; IN_216], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_216], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + 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_216] = [__v_12]; + 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); + }) +} + +const INPUT_SIZE_217: usize = 2; +const IN_217: usize = 2; +const OUT_217: usize = 1; +fn aiur_fn_217( + inp: [G; IN_217], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_217], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + 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_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_217] = [__v_30]; + 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); + }) +} + +const INPUT_SIZE_218: usize = 2; +const IN_218: usize = 2; +const OUT_218: usize = 8; +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 __v_1: G = inp[1]; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __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_217] = { let __args: [G; IN_217] = [__v_0, __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 = G::from_u64(2); + let __v_7: G = (__v_1 + __v_6); + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_7]; 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_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_217] = { let __args: [G; IN_217] = [__v_0, __v_10]; 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_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_217] = { let __args: [G; IN_217] = [__v_0, __v_13]; 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_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_217] = { let __args: [G; IN_217] = [__v_0, __v_16]; 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_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_217] = { let __args: [G; IN_217] = [__v_0, __v_19]; 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_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_217] = { let __args: [G; IN_217] = [__v_0, __v_22]; 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_23: G = __r_arr[0]; + let __ret: [G; OUT_218] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23]; + 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 = 16; +const IN_219: usize = 16; +const OUT_219: usize = 0; +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 = 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_219] = []; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_220: usize = 1; +const IN_220: usize = 1; +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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_220] = [__v_2]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_221: usize = 17; +const IN_221: usize = 17; +const OUT_221: usize = 12; +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 __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_219] = { let __args: [G; IN_219] = [__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[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)? } }; + break '__mc_0 []; + }, + _ => { + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__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[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)? } }; + 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_232] = { let __args: [G; IN_232] = [__v_263, __v_331]; 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_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_221] = [__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[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 = 13; +const IN_222: usize = 13; +const OUT_222: usize = 1; +fn aiur_fn_222( + inp: [G; IN_222], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_222], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + 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_231] = { let __args: [G; IN_231] = [__v_26]; 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_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_233] = { let __args: [G; IN_233] = [__v_141, __v_147]; 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_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_233] = { let __args: [G; IN_233] = [__v_168, __v_174]; 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_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_233] = { let __args: [G; IN_233] = [__v_176, __v_180]; 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_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_238] = { let __args: [G; IN_238] = [__v_72]; 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_399: G = __r_arr[0]; + match __v_34.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_34]; 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_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_233] = { let __args: [G; IN_233] = [__v_223, __v_407]; 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_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_233] = { let __args: [G; IN_233] = [__v_473, __v_477]; 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_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_239] = { let __args: [G; IN_239] = [__v_58]; 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_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_239] = { let __args: [G; IN_239] = [__v_60]; 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_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_239] = { let __args: [G; IN_239] = [__v_53]; 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_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_239] = { let __args: [G; IN_239] = [__v_18]; 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_500: G = __r_arr[0]; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_8]; 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_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_238] = { let __args: [G; IN_238] = [__v_72]; 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_505: G = __r_arr[0]; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_26]; 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_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_236] = { let __args: [G; IN_236] = [__v_36]; 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_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_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_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_231] = { let __args: [G; IN_231] = [__v_42]; 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_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_222] = [__v_69]; + 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 = 28; +const IN_223: usize = 28; +const OUT_223: usize = 8; +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 __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_221] = { let __args: [G; IN_221] = [__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[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_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_222] = { let __args: [G; IN_222] = [__v_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[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_40: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_40]; 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_41: G = __r_arr[0]; + let __v_42: G = G::from_u64(0); + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_41, __v_42]; 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_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_236] = { let __args: [G; IN_236] = [__v_41]; 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_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_217] = { let __args: [G; IN_217] = [__v_41, __v_47]; 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_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_218] = { let __args: [G; IN_218] = [__v_41, __v_49]; 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_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_223] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; + 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); + }, + _ => { + let __v_45: G = G::from_u64(2); + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_41, __v_45]; 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_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_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[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_41]; 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_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_217] = { let __args: [G; IN_217] = [__v_41, __v_56]; 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_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_218] = { let __args: [G; IN_218] = [__v_41, __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 = __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_223] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; + 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); + }, + } + }) +} + +const INPUT_SIZE_224: usize = 35; +const IN_224: usize = 35; +const OUT_224: usize = 0; +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 = 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_223] = { let __args: [G; IN_223] = [__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[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_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_219] = { let __args: [G; IN_219] = [__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[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_224] = []; + 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 = 36; +const IN_225: usize = 36; +const OUT_225: usize = 0; +fn aiur_fn_225( + inp: [G; IN_225], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_225], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + 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_223] = { let __args: [G; IN_223] = [__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[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_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_223] = { let __args: [G; IN_223] = [__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[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_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_216] = { let __args: [G; IN_216] = [__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[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_54: G = __r_arr[0]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_54]; 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_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __v_57: G = __r_arr[2]; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__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[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_58: G = __r_arr[0]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_58]; 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_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_215] = { let __args: [G; IN_215] = [__v_67]; 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_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_225] = []; + 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 = 16; +const IN_226: usize = 16; +const OUT_226: usize = 0; +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 = 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_224] = { let __args: [G; IN_224] = [__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[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 __ret: [G; OUT_226] = []; + 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); + }, + 1u64 => { + let __v_251: G = G::from_u64(1); + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__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[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 __ret: [G; OUT_226] = []; + 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); + }, + 2u64 => { + let __v_251: G = G::from_u64(0); + let __v_252: G = G::from_u64(0); + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__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[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 __ret: [G; OUT_226] = []; + 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); + }, + 3u64 => { + let __v_251: G = G::from_u64(0); + let __v_252: G = G::from_u64(1); + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__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[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 __ret: [G; OUT_226] = []; + 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); + }, + 4u64 => { + let __v_251: G = G::from_u64(1); + let __v_252: G = G::from_u64(0); + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__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[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 __ret: [G; OUT_226] = []; + 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); + }, + 5u64 => { + let __v_251: G = G::from_u64(1); + let __v_252: G = G::from_u64(1); + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__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[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 __ret: [G; OUT_226] = []; + 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); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_165.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_227: usize = 2; +const IN_227: usize = 2; +const OUT_227: usize = 1; +fn aiur_fn_227( + inp: [G; IN_227], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_227], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __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_227] = [__v_4]; + 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); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_228: usize = 1; +const IN_228: usize = 1; +const OUT_228: usize = 1; +fn aiur_fn_228( + inp: [G; IN_228], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_228], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_228] = [__v_4]; + 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); + }, + 0u64 => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_228] = [__v_4]; + 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); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_229: usize = 2; +const IN_229: usize = 2; +const OUT_229: usize = 2; +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 __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_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_229] = [__v_4, __v_5]; + 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); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_230: usize = 1; +const IN_230: usize = 1; +const OUT_230: usize = 1; +fn aiur_fn_230( + inp: [G; IN_230], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_230], 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_230] = [__v_6]; + 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); + }, + 0u64 => { + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__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 __v_8: G = (__v_6 + __v_7); + let __ret: [G; OUT_230] = [__v_8]; + 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_1.as_canonical_u64())); + }, + } + }) +} + +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_231], 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_231] = [__v_5]; + 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__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_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_231] = [__v_7]; + 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_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_232: usize = 2; +const IN_232: usize = 2; +const OUT_232: usize = 1; +fn aiur_fn_232( + inp: [G; IN_232], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_232], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __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_232] = [__v_1]; + 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_12: G = G::from_u64(0); + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_11, __v_1]; 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_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_232] = [__v_14]; + 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_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_233: usize = 2; +const IN_233: usize = 2; +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_233], 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_233] = [__v_1]; + 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 __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; 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 = { 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_233] = [__v_7]; + 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_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_234: usize = 2; +const IN_234: usize = 2; +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 __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_234] = [__v_0]; + 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); + }, + _ => { + let __v_2: G = G::from_u64(1); + let __v_3: G = (__v_1 - __v_2); + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_3]; 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_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_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); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.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; 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_235] = [__v_8]; + 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_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_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_235] = [__v_10]; + 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 = 1; +const IN_236: usize = 1; +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 __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_236] = [__v_11]; + 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 __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_10]; 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_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_236] = [__v_13]; + 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_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_237: usize = 2; +const IN_237: usize = 2; +const OUT_237: usize = 4; +fn aiur_fn_237( + inp: [G; IN_237], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_237], 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_242] = { let __args: [G; IN_242] = [__v_0, __v_1]; 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_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_237] = [__v_4, __v_5, __v_6, __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_3.as_canonical_u64())); + }, + } + }) +} + +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_238], 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_238] = [__v_9]; + 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_238] = { let __args: [G; IN_238] = [__v_8]; 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_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_238] = [__v_11]; + 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_1.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; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_239] = [__v_4]; + 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_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __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_239] = [__v_6]; + if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_240: usize = 2; +const IN_240: usize = 2; +const OUT_240: usize = 8; +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 __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 __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_240] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_241: usize = 2; +const IN_241: usize = 2; +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_241], 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_241] = [__v_0]; + 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); + }, + _ => { + let __v_2: G = G::from_u64(1); + let __v_3: G = (__v_1 - __v_2); + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0, __v_3]; 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_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_241] = [__v_8]; + 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_5.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_242: usize = 2; +const IN_242: usize = 2; +const OUT_242: usize = 1; +fn aiur_fn_242( + inp: [G; IN_242], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_242], 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_242] = [__v_0]; + 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); + }, + _ => { + let __v_2: G = G::from_u64(1); + let __v_3: G = (__v_1 - __v_2); + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __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 __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_242] = [__v_10]; + 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_5.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_243: usize = 2; +const IN_243: usize = 2; +const OUT_243: usize = 1; +fn aiur_fn_243( + inp: [G; IN_243], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_243], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_243] = [__v_0]; + 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); + }, + _ => { + let __v_2: G = G::from_u64(1); + let __v_3: G = (__v_1 - __v_2); + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __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 __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_243] = [__v_14]; + 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_5.as_canonical_u64())); + }, + } + }, + } + }) +} + +pub(crate) fn execute_generated( + fun_idx: usize, + args: &[G], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, +) -> Result, 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()); + }, + _ => { + 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..6a6a4ef81 --- /dev/null +++ b/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs @@ -0,0 +1,329 @@ +//! 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], +} + +/// 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>], +} + +/// 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>, 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>, String> { + decode_keyed_blobs(blob, "aggr trees").map(|entries| { + entries.into_iter().map(|(root, bytes)| AggrTree { root, bytes }).collect() + }) +} + +fn decode_keyed_blobs<'a>( + blob: &'a [u8], + label: &str, +) -> Result, 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 { + 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, 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 { + 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 { + 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 { + 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` mirrors `Toplevel::execute`'s signature so this fn can be +// used as an `impl Fn(&Toplevel, _, Vec, _) -> _` 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, + io_buffer: &mut IOBuffer, +) -> Result<(QueryRecord, Vec), 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. +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]); + + io +} + +#[cfg(test)] +mod tests { + use super::*; + use multi_stark::p3_field::PrimeField64; + + fn info(io: &IOBuffer, channel: u8, key: Vec) -> (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 { + 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 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, + }; + + 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]); + assert_eq!(info(&io, 6, index_key(0)), (0, 1)); + 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]); + + blob.push(11); + assert!(decode_aggr_preimages(&blob).is_err()); + assert!(decode_aggr_trees(&[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; From 91d1dd12465f67f1f06d99a30273067b290bf3ac Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Sat, 29 Aug 2026 08:36:39 -0400 Subject: [PATCH 23/44] aggregate: converge production pipeline on ixAggr Replace the legacy lift/join entrypoints with the heterogeneous ix_aggr system across aggregate, verification, cache, and codegen paths. Preserve wrap-first and direct-join policies behind one proof identity and cache namespace. Add the converged 91-check semantic suite and a deterministic 132-case activation audit covering shapes 0 through 9 twice, with no unobserved circuits. --- Ix/Aggr.lean | 40 +- Ix/Aggr/Circuit.lean | 141 +- Ix/Aggr/Host.lean | 44 +- Ix/Aiur/Protocol.lean | 6 +- Ix/Aiur/Semantics/BytecodeFfi.lean | 9 +- Ix/Cli/AggrCmd.lean | 353 ---- Ix/Cli/AggregateCmd.lean | 404 +++-- Ix/Cli/CodegenCmd.lean | 6 +- Ix/Cli/VerifyCmd.lean | 111 +- Main.lean | 2 - Tests/Aggr.lean | 279 ++- Tests/AggrActivation.lean | 554 ++++++ Tests/AggrSemantics.lean | 586 ++++++ Tests/Main.lean | 17 +- Tests/MultiStark.lean | 15 +- Tests/MultiStarkActivation.lean | 532 ------ crates/ffi/src/aiur/protocol.rs | 10 +- crates/ixvm-codegen/src/aiur_ix_aggr.rs | 1575 ++++++++++++----- .../ixvm-codegen/src/aiur_ix_aggr_runner.rs | 43 +- lakefile.lean | 4 + 20 files changed, 3126 insertions(+), 1605 deletions(-) delete mode 100644 Ix/Cli/AggrCmd.lean create mode 100644 Tests/AggrActivation.lean create mode 100644 Tests/AggrSemantics.lean delete mode 100644 Tests/MultiStarkActivation.lean diff --git a/Ix/Aggr.lean b/Ix/Aggr.lean index 878bd4ab1..e7861ce4a 100644 --- a/Ix/Aggr.lean +++ b/Ix/Aggr.lean @@ -85,13 +85,18 @@ def ChildKind.code : ChildKind → Nat | .ixvm => 0 | .aggr => 1 -/-- The advice byte selecting the verified form: `0`/`1` wrap one IxVM / -`ix_aggr` child; `2`–`5` fold a pair, `2 + 2·left + right` with IxVM = 0 and -`ix_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 @@ -131,6 +136,28 @@ 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 @@ -153,6 +180,13 @@ 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) diff --git a/Ix/Aggr/Circuit.lean b/Ix/Aggr/Circuit.lean index e76c874e2..b351c22fc 100644 --- a/Ix/Aggr/Circuit.lean +++ b/Ix/Aggr/Circuit.lean @@ -6,8 +6,8 @@ public import Ix.MultiStark.Verifier /-! # Heterogeneous recursive aggregation circuit -One entrypoint, `ix_aggr`, subsumes lifting and joining. A non-deterministic -shape hint (IO channel 6) selects one of five verified forms: +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 | |-------|---------------------------|-----------------------------------------| @@ -17,6 +17,10 @@ shape hint (IO channel 6) selects one of five verified forms: | 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 @@ -45,13 +49,18 @@ Child claims normalize to one `CheckEnv` statement each: * `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. Pair shapes open both `CheckEnv` preimages (channel 4), +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. @@ -66,7 +75,7 @@ not stored values to be globally deduplicated. | 3 | `[0]` | 80-byte allowed blob | | 4 | packed digest | `CheckEnv` claim preimages | | 5 | raw 32-byte root | serialized canonical `AssumptionTree`s | -| 6 | `[0]` | one shape byte (0–5) | +| 6 | `[0]` / address | shape byte (0–9) / structural path choice | -/ public section @@ -432,6 +441,84 @@ def circuit := ⟦ } } + /- ## 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 { @@ -616,6 +703,40 @@ def circuit := ⟦ () } + -- 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)`, @@ -643,8 +764,8 @@ def circuit := ⟦ -- Shape hint: exactly one advice byte. -- 0 = wrap IxVM 1 = wrap self - -- 2 = (IxVM, IxVM) 3 = (IxVM, self) - -- 4 = (self, IxVM) 5 = (self, 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); @@ -664,6 +785,14 @@ def circuit := ⟦ 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), } } ⟧ diff --git a/Ix/Aggr/Host.lean b/Ix/Aggr/Host.lean index aae894521..3cc277479 100644 --- a/Ix/Aggr/Host.lean +++ b/Ix/Aggr/Host.lean @@ -6,18 +6,21 @@ public import Std.Data.HashSet /-! # Host-side aggregate statement folding -The circuit rechecks all of this from serialized trees. These helpers give -the CLI, tests, and benchmarks one implementation for constructing fold -outputs plus their channel-5 advice. +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 canonical trees whose roots it -commits to. `assumptions = none` is represented by no tree, never by an empty -or padding-only serialization. -/ +/-- 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 @@ -62,8 +65,8 @@ def ofClaim (claim : Ix.Claim) private def assumptionLeaves (statement : CheckEnvTrees) : Array Address := statement.assumptions.map (·.leaves) |>.getD #[] -/-- The sorted, deduplicated assumption-candidate stream of a pair fold: -`assumptionsL ∪ assumptionsR`. -/ +/-- 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 @@ -87,6 +90,24 @@ def join (left right : CheckEnvTrees) : CheckEnvTrees := (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 := @@ -94,6 +115,13 @@ def adviceTrees (left right output : CheckEnvTrees) : Array Ix.AssumptionTree := #[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 diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 1ffd3178b..54de01169 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -181,8 +181,8 @@ opaque proveMultiStarkJoin (system : @& AiurSystem) /-- 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 blobs are produced by -`Aggr.preimagesBlob` and `Aggr.treesBlob`; wrap shapes pass empty +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 @@ -193,7 +193,7 @@ opaque proveIxAggr (system : @& AiurSystem) (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G) (shape : @& Nat) (leftProofAdviceBytes rightProofAdviceBytes ixvmVkBytes selfVkBytes : @& ByteArray) (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray) - (preimagesBlob treesBlob : @& ByteArray) (useBytecode : Bool := false) : + (preimagesBlob treesBlob pathsBlob : @& ByteArray) (useBytecode : Bool := false) : Except String (Array G × Proof) @[extern "rs_aiur_system_prove_addr_with_env"] diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index af11293e1..36ec47317 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -196,10 +196,11 @@ opaque executeMultiStarkJoin (toplevel : @& Bytecode.Toplevel) /-- 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` and `treesBlob` use the compact +per-byte Lean field boxing; `preimagesBlob`, `treesBlob`, and `pathsBlob` use the compact count/key/length framing produced by `Aggr.preimagesBlob` and -`Aggr.treesBlob`. Rust expands them directly into IO channels 0–6 (the -shape hint lands on channel 6). Wrap shapes pass empty right-child blobs — +`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 @@ -209,7 +210,7 @@ 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 : @& ByteArray) (useBytecode : Bool := false) : + (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/AggrCmd.lean b/Ix/Cli/AggrCmd.lean deleted file mode 100644 index 046e2d344..000000000 --- a/Ix/Cli/AggrCmd.lean +++ /dev/null @@ -1,353 +0,0 @@ -/- - `ix aggr --ixe E --ixes M ...` - - Fold persisted IxVM shard proofs into one recursive `ix_aggr` proof of the - whole environment. There is no lift stage: shard proofs enter the recursion - system directly as `ix_aggr` join children, and the tree is a balanced - bisection over the manifest's nonempty shards. Because the statement fold is - canonical (sorted-set union/difference), the root claim is independent of - the fold order; a single-shard environment is closed with one wrap so the - persisted root is always an `ix_aggr` proof. - - This first host driver is intentionally serial and cache-free. Its slot - model and content-addressed inputs make parallel scheduling and resumable - cache entries follow-up optimizations rather than protocol changes. --/ -module -public import Cli -public import Ix.Aggr -public import Ix.Cli.CheckCmd -public import Ix.IxVM -public import Ix.IxVM.ClaimHarness -public import Ix.Store - -public section - -namespace Ix.Cli.AggrCmd - -structure PreparedShard where - claim : Ix.Claim - statement : Aggr.CheckEnvTrees - -/-- One aggregation slot: either a raw shard proof (`kind = .ixvm`, the -IxVM `verify_claim` wrapper) or an `ix_aggr` output (`kind = .aggr`). Proofs -stay compact as `Aiur.Proof` values between folds and are expanded only at a -recursive advice boundary. `claimsBytes` are the serialized claims a parent -feeds to IO channel 2. -/ -structure Slot where - kind : Aggr.ChildKind - statement : Aggr.CheckEnvTrees - outerClaim : Array Aiur.G - proof : Aiur.Proof - claimsBytes : ByteArray - -/-- Everything a fold step needs, resolved once before proving. -/ -structure Backend where - ixvmSystem : Aiur.AiurSystem - aggrSystem : Aiur.AiurSystem - aggrIdx : Aiur.Bytecode.FunIdx - ixvmVk : ByteArray - aggrVk : ByteArray - allowed : ByteArray - -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 ← Aggr.CheckEnvTrees.ofClaim claim trees - pure { claim, statement } - -private def compileToplevel (label : String) - (source : Except Aiur.Global Aiur.Source.Toplevel) : - Except String Aiur.CompiledToplevel := do - match source with - | .error e => throw s!"{label} toplevel merge failed: {e}" - | .ok top => match top.compile with - | .error e => throw s!"{label} compilation failed: {e}" - | .ok compiled => pure compiled - -/-- The serialized `verify_claim` claims of one shard wrapper — what the -IxVM prover's Fiat-Shamir transcript observed, and what a parent decodes. -/ -private def shardClaimsBytes (verifyIdx : Aiur.Bytecode.FunIdx) - (claim : Ix.Claim) : ByteArray := - let digestKey := IxVM.ClaimHarness.packedDigestKey - (Address.blake3 (Ix.Claim.ser claim)) - MultiStark.serializeClaims #[Aiur.buildClaim verifyIdx digestKey #[]] - -private def kindLabel : Aggr.ChildKind → String - | .ixvm => "shard" - | .aggr => "fold" - -/-- Expand one compact child proof into the per-query transport consumed by -the recursive verifier. The child kind selects the verifying system whose -wire codec must be used. -/ -private def proofAdviceBytes (backend : Backend) (slot : Slot) : - Except String ByteArray := - let system := match slot.kind with - | .ixvm => backend.ixvmSystem - | .aggr => backend.aggrSystem - system.proofToAdviceBytes slot.outerClaim slot.proof - -/-- Prove one pair fold and natively verify its output. -/ -private def proveJoin (backend : Backend) (left right : Slot) : - IO (Except String Slot) := do - let output := left.statement.join right.statement - let outputClaimBytes := Ix.Claim.ser output.claim - let shape := Aggr.shapeCode (left.kind, some right.kind) - let pubInput := Aggr.pubInput backend.allowed outputClaimBytes - let preimages := Aggr.preimagesBlob - #[Ix.Claim.ser left.statement.claim, Ix.Claim.ser right.statement.claim] - let trees := Aggr.treesBlob - (Aggr.CheckEnvTrees.adviceTrees left.statement right.statement output) - IO.println s!"[aggr] folding {kindLabel left.kind} + {kindLabel right.kind} \ - ({output.subjectCount} subjects)" - (← IO.getStdout).flush - let leftProofAdvice ← match proofAdviceBytes backend left with - | .error e => return .error s!"left {kindLabel left.kind} proof advice encoding failed: {e}" - | .ok bytes => pure bytes - let rightProofAdvice ← match proofAdviceBytes backend right with - | .error e => return .error s!"right {kindLabel right.kind} proof advice encoding failed: {e}" - | .ok bytes => pure bytes - let result := backend.aggrSystem.proveIxAggr backend.aggrIdx pubInput shape - leftProofAdvice rightProofAdvice backend.ixvmVk backend.aggrVk - left.claimsBytes right.claimsBytes outputClaimBytes backend.allowed - preimages trees - let (outerClaim, proof) ← match result with - | .error e => return .error s!"fold proving failed: {e}" - | .ok result => pure result - match backend.aggrSystem.verify outerClaim proof with - | .error e => return .error s!"fold output failed native verification: {e}" - | .ok () => pure () - return .ok { - kind := .aggr - statement := output - outerClaim - proof - claimsBytes := MultiStark.serializeClaims #[outerClaim] - } - -/-- Prove one wrap of an IxVM shard slot (single-shard environments), so the -persisted root is always an `ix_aggr` proof. -/ -private def proveWrap (backend : Backend) (child : Slot) : - IO (Except String Slot) := do - let outputClaimBytes := Ix.Claim.ser child.statement.claim - let shape := Aggr.shapeCode (child.kind, none) - let pubInput := Aggr.pubInput backend.allowed outputClaimBytes - IO.println s!"[aggr] wrapping single {kindLabel child.kind}" - (← IO.getStdout).flush - let childProofAdvice ← match proofAdviceBytes backend child with - | .error e => return .error s!"{kindLabel child.kind} proof advice encoding failed: {e}" - | .ok bytes => pure bytes - let result := backend.aggrSystem.proveIxAggr backend.aggrIdx pubInput shape - childProofAdvice ByteArray.empty backend.ixvmVk backend.aggrVk - child.claimsBytes ByteArray.empty outputClaimBytes backend.allowed - (Aggr.preimagesBlob #[]) (Aggr.treesBlob #[]) - let (outerClaim, proof) ← match result with - | .error e => return .error s!"wrap proving failed: {e}" - | .ok result => pure result - match backend.aggrSystem.verify outerClaim proof with - | .error e => return .error s!"wrap output failed native verification: {e}" - | .ok () => pure () - return .ok { - kind := .aggr - statement := child.statement - outerClaim - proof - claimsBytes := MultiStark.serializeClaims #[outerClaim] - } - -/-- Balanced bisection fold over `slots[lo:hi]`. Canonical set folds make the -root claim independent of this shape; balance minimizes depth. -/ -private partial def foldRange (backend : Backend) (slots : Array Slot) - (lo hi : Nat) : IO (Except String Slot) := do - if hi - lo == 1 then - let some slot := slots[lo]? - | return .error s!"internal: fold range references missing slot {lo}" - return .ok slot - let mid := lo + (hi - lo) / 2 - let left ← match ← foldRange backend slots lo mid with - | .error e => return .error e - | .ok slot => pure slot - let right ← match ← foldRange backend slots mid hi with - | .error e => return .error e - | .ok slot => pure slot - proveJoin backend left right - -def runAggrCmd (p : Cli.Parsed) : IO UInt32 := do - let some ixePath := (p.flag? "ixe").map (·.as! String) | do - p.printError "error: aggr requires --ixe " - return 1 - let some manifestPath := (p.flag? "ixes").map (·.as! String) | do - p.printError "error: aggr requires --ixes " - return 1 - - 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 allShards ← match Ix.Cli.CheckCmd.parseIxesAllShards - (← IO.FS.readBinFile manifestPath) with - | .error e => IO.eprintln s!"manifest parse failed: {e}"; return 1 - | .ok shards => pure shards - if !(← Ix.Cli.CheckCmd.shardsCover env allShards) then return 1 - - -- Reconstruct every nonempty shard's statement from the environment once. - -- This binds proof wrappers to shards and supplies canonical fold advice. - let mut prepared : Array (Nat × PreparedShard) := #[] - let mut digestToSlot : Std.HashMap Address Nat := {} - for (blocks, shard) in allShards.mapIdx fun shard blocks => (blocks, shard) do - if (Ix.Cli.CheckCmd.ownedConstsForBlocks env blocks).isEmpty then - IO.println s!"[aggr] skipping zero-constant manifest shard {shard}" - continue - let item ← match prepareShard env blocks with - | .error e => IO.eprintln s!"prepare shard {shard}: {e}"; return 1 - | .ok item => pure item - let digest := Address.blake3 (Ix.Claim.ser item.claim) - if digestToSlot.contains digest then - IO.eprintln s!"duplicate reconstructed shard claim digest {digest} \ - (manifest shard {shard})" - return 1 - digestToSlot := digestToSlot.insert digest prepared.size - prepared := prepared.push (shard, item) - if prepared.isEmpty then - IO.eprintln "manifest contains no nonempty shard" - return 1 - - let depth := Nat.log2 (2 * prepared.size - 1) - let wrapNote := if prepared.size == 1 then " + 1 wrap" else "" - IO.println s!"[aggr] plan: {prepared.size} shard leaves, \ - {prepared.size - 1} pair folds{wrapNote} (balanced bisection, depth {depth})" - if p.hasFlag "plan-only" then return 0 - - let proofHexes := (p.variableArgsAs! String).toList - if proofHexes.length != prepared.size then - IO.eprintln s!"aggr requires exactly {prepared.size} shard proofs; \ - got {proofHexes.length}" - return 1 - - -- Proof arguments may be in any order. Match them by their bundled claim - -- and reject duplicates/collisions before starting expensive proving. - let mut proofsBySlot : 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 slot := digestToSlot.get? digest | do - IO.eprintln s!"proof {proofAddress} claim {digest} matches no manifest shard" - return 1 - let some (shard, expected) := prepared[slot]? | do - IO.eprintln s!"internal: missing prepared slot {slot}" - return 1 - if wrapper.claim != expected.claim then - IO.eprintln s!"proof {proofAddress} hit a claim-digest collision for shard {shard}" - return 1 - if proofsBySlot.contains slot then - IO.eprintln s!"more than one proof supplied for shard {shard}" - return 1 - proofsBySlot := proofsBySlot.insert slot wrapper - if proofsBySlot.size != prepared.size then - IO.eprintln "not every nonempty 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" 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 := Aiur.AiurSystem.build aggrCompiled.bytecode - Aiur.defaultCommitmentParameters Aiur.defaultFriParameters - let ixvmVk := ixvmSystem.vkBytes - let aggrVk := aggrSystem.vkBytes - let backend : Backend := { - ixvmSystem, aggrSystem, aggrIdx, ixvmVk, aggrVk - allowed := Aggr.allowedBlob ixvmVk verifyIdx aggrVk aggrIdx - } - - -- Natively pre-verify every shard proof before any expensive fold, and - -- decode proof bytes through the checked constructor: wrappers come from - -- the store, an untrusted boundary. - let mut slots : Array Slot := #[] - for (item, slot) in prepared.mapIdx fun slot item => (item, slot) do - let (shard, preparedShard) := item - let some wrapper := proofsBySlot.get? slot | do - IO.eprintln s!"internal: no proof for shard {shard}" - return 1 - let proof ← match Aiur.Proof.ofBytesChecked wrapper.proof with - | .error e => IO.eprintln s!"shard {shard} proof decode failed: {e}"; return 1 - | .ok proof => pure proof - let digestKey := IxVM.ClaimHarness.packedDigestKey - (Address.blake3 (Ix.Claim.ser preparedShard.claim)) - let innerClaim := Aiur.buildClaim verifyIdx digestKey #[] - match ixvmSystem.verify innerClaim proof with - | .error e => - IO.eprintln s!"shard {shard} proof fails native verification: {e}" - return 1 - | .ok () => pure () - slots := slots.push { - kind := .ixvm - statement := preparedShard.statement - outerClaim := innerClaim - proof - claimsBytes := shardClaimsBytes verifyIdx preparedShard.claim - } - - let folded ← match ← foldRange backend slots 0 slots.size with - | .error e => IO.eprintln e; return 1 - | .ok slot => pure slot - -- A single-shard environment still gets an `ix_aggr` root via one wrap. - let root ← match folded.kind with - | .aggr => pure folded - | .ixvm => match ← proveWrap backend folded with - | .error e => IO.eprintln e; return 1 - | .ok slot => pure slot - - let some envTree := IxVM.ClaimHarness.envCanonicalTree env | do - IO.eprintln "cannot aggregate an empty environment" - return 1 - if root.statement.subjects.root != envTree.root then - IO.eprintln s!"aggregate root subjects are {root.statement.subjects.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 - - let claim := root.statement.claim - let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) - let wrapper : Ixon.Proof := { claim, proof := root.proof.toBytes } - let proofAddress ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) - IO.println s!"[aggr] root proof: {proofAddress}" - return 0 - -end Ix.Cli.AggrCmd - -open Ix.Cli.AggrCmd in -def aggrCmd : Cli.Cmd := `[Cli| - aggr VIA runAggrCmd; - "Fold IxVM shard proofs into one recursive ix_aggr proof of the whole environment" - - FLAGS: - "ixe" : String; "Path to the serialized environment whose shards were proven." - "ixes" : String; "Path to the shard manifest defining the shard partition." - "plan-only"; "Validate coverage and print the fold plan without loading or proving shard proofs." - - 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/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index 1318f48ca..80e2b0f87 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -2,20 +2,22 @@ `ix aggregate --ixe E --ixes M ...` Bind persisted shard proof wrappers to every nonempty shard in a manifest, - lift each IxVM proof into the Multi-STARK recursion system, then execute/prove - any binary joins in the manifest's bisection-tree order. Small joins use flat - canonical subjects; joins above `--structural-above` use an O(1) - root-of-roots subject fold plus assumption-membership paths. The final - persisted wrapper carries the aggregate `CheckEnv` claim and recursive proof - bytes. + 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 - lift/join is persisted in a verified, content-addressed resume cache. + 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 @@ -33,18 +35,24 @@ structure PreparedShard where 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 - /-- Preimages needed when this slot is decoded by its parent. A lift exposes - its inner claims plus `CheckEnv`; a join exposes only its output `CheckEnv`. -/ + /-- Serialized singleton outer-claim list consumed by a parent. -/ + claimsBytes : ByteArray := ByteArray.empty + /-- Legacy benchmark preimage closure retained through M1-f. The converged + parent only needs the direct `CheckEnv` preimage for each child. -/ openPreimages : Array ByteArray /-- 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 @@ -66,6 +74,11 @@ 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 @@ -87,24 +100,55 @@ 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 -/-- Calibration-pending per-slot RAM weight used by the Lean admission gate. -/ +/-- 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.op with - | .leaf _ => aggregateLiftRamBytes - | .join _ _ => - if item.structural then aggregateStructuralJoinRamBytes - else aggregateStructuralJoinRamBytes + - item.subjectCount * aggregateFlatJoinRamPerSubjectBytes + 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 @@ -221,16 +265,17 @@ def defaultAggregateRamBudgetBytes : IO Nat := do | some total => total / 100 * 92 | none => 16 * aggregateGiB -/-- Bump when aggregate advice framing changes without changing the recursion -verifying key. Encoded as `u64` little-endian in every cache key. -/ -def aggregateCacheVersion : Nat := 1 +/-- 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 already commits to the entrypoint and public -input; joins therefore transitively pin the allowed blob and output statement. +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) @@ -285,23 +330,38 @@ def validateAggregateCacheWrapper (recursionSystem : Aiur.AiurSystem) 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) : + (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}" - scheduled := scheduled.push { op, subjectCount := count, structural := false } + 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 := count > structuralAbove + op, subjectCount := count, structural, kind := .aggr, + shape? := some shape } pure scheduled @@ -363,6 +423,99 @@ def buildAggregateSlotSpecs (plan : Array ScheduledFold) } pure specs +/-! ## Converged single-entrypoint slot derivation + +The legacy helper above remains temporarily available to the M1-e/M1-f test +and benchmark union. Production uses the helpers below exclusively. -/ + +/-- 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 @@ -560,21 +713,28 @@ private def persistAggregateCacheProof (dir : System.FilePath) (slotIdx : Nat) private def printPlan (plan : Array ScheduledFold) (shardIds : Array Nat) (structuralAbove : Nat) : IO Unit := do - let lifts := plan.countP fun item => match item.op with + 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) - IO.println s!"[aggregate] plan: {lifts} lifts + {plan.size - lifts} binary joins \ + 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 - IO.println s!" slot {slot}: lift shard {originalShard} ({item.subjectCount} subjects)" + 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} join slots {left}, {right} \ - ({item.subjectCount} subjects)" + IO.println s!" slot {slot}: {mode} shape {item.shape?.getD 255} \ + slots {left}, {right} ({item.subjectCount} subjects)" private structure AggregateProveContext where plan : Array ScheduledFold @@ -583,14 +743,12 @@ private structure AggregateProveContext where proofsByShard : Std.HashMap Nat Ixon.Proof shardIds : Array Nat ixvmSystem : Aiur.AiurSystem - recursionSystem : Aiur.AiurSystem + aggrSystem : Aiur.AiurSystem ixvmVk : ByteArray - recursionVk : ByteArray + aggrVk : ByteArray allowed : ByteArray verifyIdx : Aiur.Bytecode.FunIdx - liftIdx : Aiur.Bytecode.FunIdx - joinIdx : Aiur.Bytecode.FunIdx - structuralJoinIdx : Aiur.Bytecode.FunIdx + aggrIdx : Aiur.Bytecode.FunIdx cacheDir? : Option System.FilePath /-- Prove or resume one slot whose dependencies have already completed. The @@ -623,36 +781,59 @@ private def proveAggregateSlot (ctx : AggregateProveContext) (slotIdx : Nat) return Except.error s!"shard {originalShard} proof fails native verification: {e}" | .ok () => pure () let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] - let cached? ← match ctx.cacheDir? with - | none => pure none - | some dir => loadCachedAggregateProof dir slotIdx spec ctx.recursionSystem - 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 pubInput := MultiStark.verifierPubInput ctx.ixvmVk innerClaimsBytes - IO.println s!"[aggregate] lifting shard {originalShard} into slot {slotIdx}" - (← IO.getStdout).flush - let (outerClaim, proof) := ctx.recursionSystem.proveMultiStark - ctx.liftIdx pubInput innerProofAdvice ctx.ixvmVk innerClaimsBytes - if outerClaim != spec.outerClaim then - return .error "lift 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 { - statement := spec.statement - subjectCount := spec.subjectCount - outerClaim := spec.outerClaim - proof - proofAddress? - openPreimages := #[innerClaimsBytes, claimBytes] - } + 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 + openPreimages := #[claimBytes] + } + | .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] + openPreimages := #[claimBytes] + } | .join leftIdx rightIdx => let some left := (slots[leftIdx]?).join | return .error s!"missing completed left slot {leftIdx}" @@ -662,42 +843,52 @@ private def proveAggregateSlot (ctx : AggregateProveContext) (slotIdx : Nat) let outputClaimBytes := Ix.Claim.ser output.claim let cached? ← match ctx.cacheDir? with | none => pure none - | some dir => loadCachedAggregateProof dir slotIdx spec ctx.recursionSystem + | 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 := MultiStark.joinPubInput ctx.allowed outputClaimBytes - let leftClaimsBytes := MultiStark.serializeClaims #[left.outerClaim] - let rightClaimsBytes := MultiStark.serializeClaims #[right.outerClaim] - let preimagesBlob := MultiStark.joinPreimagesBlob - (left.openPreimages ++ right.openPreimages) + 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 - MultiStark.CheckEnvTrees.structuralAdviceTrees - left.statement right.statement output + Aggr.CheckEnvTrees.structuralAdviceTrees + leftStatement rightStatement outputStatement else - MultiStark.CheckEnvTrees.adviceTrees - left.statement right.statement output - let treesBlob := MultiStark.joinTreesBlob trees + Aggr.CheckEnvTrees.adviceTrees + leftStatement rightStatement outputStatement + let treesBlob := Aggr.treesBlob trees let pathsBlob := if item.structural then - MultiStark.joinPathsBlob - (MultiStark.CheckEnvTrees.structuralPathAdvice - left.statement right.statement output) + Aggr.pathsBlob + (Aggr.CheckEnvTrees.structuralPathAdvice + leftStatement rightStatement outputStatement) else - MultiStark.joinPathsBlob #[] - let joinFunIdx := if item.structural then ctx.structuralJoinIdx else ctx.joinIdx + Aggr.pathsBlob #[] let mode := if item.structural then "structural" else "flat" - let leftProofAdvice ← match ctx.recursionSystem.proofToAdviceBytes + 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 ctx.recursionSystem.proofToAdviceBytes + 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 result := ctx.recursionSystem.proveMultiStarkJoin joinFunIdx pubInput - leftProofAdvice rightProofAdvice ctx.recursionVk + 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 @@ -710,11 +901,13 @@ private def proveAggregateSlot (ctx : AggregateProveContext) (slotIdx : Nat) | 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] openPreimages := #[outputClaimBytes] } @@ -748,7 +941,9 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) let structuralAbove := ((p.flag? "structural-above").map (·.as! Nat)).getD defaultStructuralAbove - let plan ← match schedulePlan view.aggregationTree.foldPlan shardCounts structuralAbove with + 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 @@ -765,8 +960,9 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) let budgetSource := if maxRamGb?.isSome then "--max-ram" else "92% MemTotal" IO.println s!"[aggregate] scheduler: jobs={jobsLabel}, RAM budget \ {formatAggregateGiB ramBudgetBytes} GiB ({budgetSource}); \ - lift/structural reserve {formatAggregateGiB aggregateLiftRamBytes} GiB, \ - flat +1 MiB/subject (calibration pending)" + 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 @@ -792,7 +988,7 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) 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 lift. + -- 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 @@ -823,24 +1019,20 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) let ixvmCompiled ← match ← compileToplevel "IxVM" IxVM.ixVM with | .error e => IO.eprintln e; return 1 | .ok compiled => pure compiled - let recursionCompiled ← match ← compileToplevel "MultiStark recursion" - MultiStark.multiStark with + 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 liftIdx := recursionCompiled.getFuncIdx `verify_multi_stark_proof |>.get! - let joinIdx := recursionCompiled.getFuncIdx `join_two |>.get! - let structuralJoinIdx := recursionCompiled.getFuncIdx `join_two_structural |>.get! + let aggrIdx := aggrCompiled.getFuncIdx `ix_aggr |>.get! let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode Aiur.defaultCommitmentParameters Aiur.defaultFriParameters - let recursionSystem := MultiStark.buildRecursionSystem recursionCompiled.bytecode + let aggrSystem := MultiStark.buildRecursionSystem aggrCompiled.bytecode recursionParameters let ixvmVk := ixvmSystem.vkBytes - let recursionVk := recursionSystem.vkBytes - let allowed := MultiStark.allowedBlob ixvmVk verifyIdx recursionVk liftIdx - joinIdx structuralJoinIdx - let specs ← match buildAggregateSlotSpecs plan prepared ixvmVk recursionVk allowed - verifyIdx liftIdx joinIdx structuralJoinIdx recursionParameters with + 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 @@ -851,8 +1043,8 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) let proveContext : AggregateProveContext := { plan, specs, prepared, proofsByShard, shardIds := view.shardIds - ixvmSystem, recursionSystem, ixvmVk, recursionVk, allowed - verifyIdx, liftIdx, joinIdx, structuralJoinIdx, cacheDir? + ixvmSystem, aggrSystem, ixvmVk, aggrVk, allowed + verifyIdx, aggrIdx, cacheDir? } let slots ← match ← runAggregateDag plan slotWeights jobs ramBudgetBytes (proveAggregateSlot proveContext) true with @@ -862,6 +1054,9 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) 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 @@ -874,7 +1069,7 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) if root.statement.assumptions.isSome then IO.eprintln s!"aggregate root retains undischarged assumptions {root.statement.assumptions.map (·.root)}" return 1 - match recursionSystem.verify root.outerClaim root.proof with + match aggrSystem.verify root.outerClaim root.proof with | .error e => IO.eprintln s!"aggregate root proof failed native verification: {e}"; return 1 | .ok () => pure () @@ -896,16 +1091,17 @@ end Ix.Cli.AggregateCmd open Ix.Cli.AggregateCmd in def aggregateCmd : Cli.Cmd := `[Cli| aggregate VIA runAggregateCmd; - "Lift shard proofs and fold multi-shard manifests into one recursive aggregate" + "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 lift/join slot plan without loading or proving shard proofs." + "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)." diff --git a/Ix/Cli/CodegenCmd.lean b/Ix/Cli/CodegenCmd.lean index 608f837c4..79b595c31 100644 --- a/Ix/Cli/CodegenCmd.lean +++ b/Ix/Cli/CodegenCmd.lean @@ -57,7 +57,7 @@ def targets : List Target := [ outPath := "crates/ixvm-codegen/src/aiur_ixvm.rs" }, { label := "multi-stark", source := MultiStark.multiStark, outPath := "crates/ixvm-codegen/src/aiur_multi_stark.rs" }, - -- `ix aggr` proving/verification must select the SAME toplevel for its + -- `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, @@ -112,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 e8db79e3a..ccd089bd1 100644 --- a/Ix/Cli/VerifyCmd.lean +++ b/Ix/Cli/VerifyCmd.lean @@ -18,6 +18,7 @@ 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 @@ -87,25 +88,14 @@ def buildBackend : IO (Except String (Aiur.AiurSystem × Aiur.CompiledToplevel)) structure AggregateBackend where system : Aiur.AiurSystem - ixvmVk : ByteArray - verifyClaimIdx : Aiur.Bytecode.FunIdx - liftIdx : Aiur.Bytecode.FunIdx - flatJoinIdx : Aiur.Bytecode.FunIdx - structuralJoinIdx : Aiur.Bytecode.FunIdx + aggrIdx : Aiur.Bytecode.FunIdx allowed : ByteArray -inductive AggregateRootKind where - | lift - | flat - | structural - deriving BEq, Repr - structure ExpectedAggregate where claim : Ix.Claim - kinds : Array AggregateRootKind /-- Build the two deterministic systems whose identities are committed by an -aggregate root: the IxVM vk and the combined lift/join recursion vk. -/ +aggregate root: the IxVM vk and the single-entrypoint recursion vk. -/ private def buildAggregateBackend (recursionParameters : MultiStark.RecursionParameters) : IO (Except String AggregateBackend) := do @@ -114,49 +104,42 @@ private def buildAggregateBackend | .ok top => match top.compile with | .error e => return .error s!"IxVM compilation failed: {e}" | .ok compiled => pure compiled - let recursionCompiled ← match MultiStark.multiStark with + 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 liftIdx := recursionCompiled.getFuncIdx `verify_multi_stark_proof |>.get! - let joinIdx := recursionCompiled.getFuncIdx `join_two |>.get! - let structuralJoinIdx := recursionCompiled.getFuncIdx `join_two_structural |>.get! + let aggrIdx := aggrCompiled.getFuncIdx `ix_aggr |>.get! let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode commitmentParameters friParameters - let recursionSystem := MultiStark.buildRecursionSystem recursionCompiled.bytecode + let aggrSystem := MultiStark.buildRecursionSystem aggrCompiled.bytecode recursionParameters let ixvmVk := ixvmSystem.vkBytes - let recursionVk := recursionSystem.vkBytes - let allowed := MultiStark.allowedBlob ixvmVk verifyIdx - recursionVk liftIdx joinIdx structuralJoinIdx + let aggrVk := aggrSystem.vkBytes + let allowed := Aggr.allowedBlob ixvmVk verifyIdx aggrVk aggrIdx return .ok { - system := recursionSystem - ixvmVk - verifyClaimIdx := verifyIdx - liftIdx - flatJoinIdx := joinIdx - structuralJoinIdx + system := aggrSystem + aggrIdx allowed } private def shardStatement (env : Ixon.Env) (blocks : Array Address) : - Except String MultiStark.CheckEnvTrees := do + Except String Aggr.CheckEnvTrees := do let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks env blocks let (claim, trees) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned - MultiStark.CheckEnvTrees.ofClaim claim trees + Aggr.CheckEnvTrees.ofClaim claim trees -/-- Reproduce the lift/flat/structural statement fold from a coverage-validated +/-- 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 (MultiStark.CheckEnvTrees × AggregateRootKind) := do + 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 MultiStark.CheckEnvTrees := #[] + let mut slots : Array Aggr.CheckEnvTrees := #[] for item in plan do match item.op with | .leaf shard => @@ -173,28 +156,7 @@ def expectedFromManifest (env : Ixon.Env) else leftStatement.join rightStatement let some root := slots.back? | throw "aggregate manifest produced no root" - let some rootPlan := plan.back? | throw "aggregate manifest produced no root slot" - let kind := match rootPlan.op with - | .leaf _ => AggregateRootKind.lift - | .join _ _ => if rootPlan.structural then .structural else .flat - pure (root, kind) - -/-- Reconstruct the exact outer claim of a single-shard lift from the bundled -`CheckEnv` statement. This is the verification-side inverse of the leaf arm in -`ix aggregate`: the wrapper claim determines the nested IxVM `verify_claim`, -whose serialized singleton list determines the lift public input. -/ -def aggregateLiftOuterClaim (ixvmVk : ByteArray) - (verifyClaimIdx liftIdx : Aiur.Bytecode.FunIdx) (claim : Ix.Claim) : Array Aiur.G := - let claimBytes := Ix.Claim.ser claim - let verifyInput := IxVM.ClaimHarness.packedDigestKey (Address.blake3 claimBytes) - let innerClaim := Aiur.buildClaim verifyClaimIdx verifyInput #[] - let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] - Aiur.buildClaim liftIdx (MultiStark.verifierPubInput ixvmVk innerClaimsBytes) #[] - -private def aggregateRootKindLabel : AggregateRootKind → String - | .lift => "lift" - | .flat => "flat" - | .structural => "structural" + pure root private def verifyAggregateProof (backend : AggregateBackend) (expected? : Option ExpectedAggregate) (proofAddr : Address) : IO UInt32 := do @@ -213,27 +175,15 @@ private def verifyAggregateProof (backend : AggregateBackend) | .error e => IO.eprintln s!"error: aggregate proof {proofAddr} does not decode: {e}" return 1 - let claimBytes := Ix.Claim.ser wrapper.claim - let joinPubInput := MultiStark.joinPubInput backend.allowed claimBytes - let outerClaim : AggregateRootKind → Array Aiur.G - | .lift => aggregateLiftOuterClaim backend.ixvmVk backend.verifyClaimIdx - backend.liftIdx wrapper.claim - | .flat => Aiur.buildClaim backend.flatJoinIdx joinPubInput #[] - | .structural => Aiur.buildClaim backend.structuralJoinIdx joinPubInput #[] - let kinds := expected?.map (·.kinds) |>.getD - #[.lift, .flat, .structural] - let mut errors : Array String := #[] - for kind in kinds do - match backend.system.verify (outerClaim kind) proof with - | .ok () => - IO.println s!"ok: {aggregateRootKindLabel kind} aggregate proof \ - {proofAddr} verifies {wrapper.claim}" - return 0 - | .error e => - errors := errors.push s!"{aggregateRootKindLabel kind}: {e}" - IO.eprintln s!"error: aggregate verification failed: \ - {String.intercalate "; " errors.toList}" - 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 @@ -327,10 +277,7 @@ def runVerifyCmdWith (recursionParameters : MultiStark.RecursionParameters) 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 - kinds := #[.lift, .flat] - }) + 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 @@ -340,14 +287,14 @@ def runVerifyCmdWith (recursionParameters : MultiStark.RecursionParameters) | .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, kind) ← match expectedFromManifest env view structuralAbove with + 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, kinds := #[kind] }) + pure (some { claim := statement.claim }) | none, some _ => unreachable! let backend ← match ← buildAggregateBackend recursionParameters with | .error e => IO.eprintln e; return 1 @@ -388,7 +335,7 @@ def verifyCmd : Cli.Cmd := `[Cli| "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). 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 aggregate-first roots. With --ixe alone, accepts a single lift or all-flat canonical root; add --ixes for the exact lift/flat/structural manifest root." + "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: diff --git a/Main.lean b/Main.lean index f6cc3b0e1..6963f1ad3 100644 --- a/Main.lean +++ b/Main.lean @@ -1,7 +1,6 @@ --import Ix.Cli.StoreCmd import Ix.Cli.AddrOfCmd import Ix.Cli.AggregateCmd -import Ix.Cli.AggrCmd import Ix.Cli.BenchReport import Ix.Cli.CheckCmd import Ix.Cli.CodegenCmd @@ -36,7 +35,6 @@ def ixCmd : Cli.Cmd := `[Cli| SUBCOMMANDS: --storeCmd; - aggrCmd; benchCmd; aggregateCmd; catalogCmd; diff --git a/Tests/Aggr.lean b/Tests/Aggr.lean index ba1402198..1c5c9c34c 100644 --- a/Tests/Aggr.lean +++ b/Tests/Aggr.lean @@ -4,13 +4,14 @@ 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 five shapes, with +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 @@ -21,8 +22,9 @@ real Multi-STARK child proofs from two cheap stand-in systems: 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, and the canonical union/difference fold. -The negative cases each break exactly one of those bindings. +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 @@ -67,7 +69,9 @@ private def mkIO (allowed : ByteArray) (shape : Nat) (ixvmVk aggrVk : ByteArray) (children : Array ChildSlot) (outClaim? : Option ByteArray := none) (preimages : Array ByteArray := #[]) - (trees : Array Ix.AssumptionTree := #[]) : IOBuffer := Id.run do + (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 @@ -79,6 +83,8 @@ private def mkIO (allowed : ByteArray) (shape : Nat) 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 @@ -129,6 +135,83 @@ def smokeSuite : IO UInt32 := do 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 + 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 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)]. @@ -155,19 +238,30 @@ def smokeSuite : IO UInt32 := do 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 := #[]) := + (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) + (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 @@ -179,6 +273,24 @@ def smokeSuite : IO UInt32 := do 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`) @@ -198,12 +310,101 @@ def smokeSuite : IO UInt32 := do leftIxvm.proofAdviceBytes rightIxvm.proofAdviceBytes ixvmVk aggrVk leftIxvm.claimsBytes rightIxvm.claimsBytes outputClaimBytes allowed (Aggr.preimagesBlob #[leftClaimBytes, rightClaimBytes]) - (Aggr.treesBlob adviceTrees) + (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.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 @@ -261,20 +462,65 @@ def smokeSuite : IO UInt32 := do 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 "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, @@ -284,6 +530,23 @@ def smokeSuite : IO UInt32 := do 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 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/Main.lean b/Tests/Main.lean index 134e2f560..8a33983c6 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -53,8 +53,9 @@ import Tests.Ix.CondenseM import Tests.FFI import Tests.Keccak import Tests.MultiStark -import Tests.MultiStarkActivation import Tests.Aggr +import Tests.AggrSemantics +import Tests.AggrActivation import Tests.Cli import Tests.ShardMap import Tests.Ix.EnvBody @@ -187,9 +188,9 @@ def primaryRunners : List (String × IO UInt32) := [ ("multi-stark", Tests.MultiStark.selfTestSuite), ("recursive-verifier", Tests.MultiStark.endToEndSuite), ("aggregate-first", Tests.MultiStark.joinSmokeSuite), - -- Heterogeneous aggregation circuit: all five `ix_aggr` shapes over - -- stand-in child systems, plus one negative case per broken binding. - ("ix-aggr", Tests.Aggr.smokeSuite), + -- 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 -/ @@ -323,11 +324,11 @@ def main (args : List String) : IO UInt32 := do if args.contains "cli" then return ← Tests.Cli.suite - -- Section 13 WP-D diagnostic: keep the 98-case, twice-executed activation - -- matrix out of the default primary suite while making its gate explicit and - -- independent of the large compiled Lean environment used by ignored tests. + -- 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.MultiStark.activationAudit + return ← Tests.Aggr.activationAudit let runIgnored := args.contains "--ignored" let includeIgnored := args.contains "--include-ignored" diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index 21e373e0f..81e8a2ad6 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -492,8 +492,12 @@ def joinSmokeSuite : IO UInt32 := do | _ => false let reconstructedLiftClaim := - Ix.Cli.VerifyCmd.aggregateLiftOuterClaim fakeIxvmVk verifyIdx liftIdx - leftStatement.claim + 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 @@ -907,9 +911,9 @@ def joinSmokeSuite : IO UInt32 := do pruned.aggregationTree == .leaf 0 && counts == #[1] | .error _ => false | .error _ => false - let singleManifestLiftRoot : Bool := match singleManifest with + let singleManifestValueRoot : Bool := match singleManifest with | .ok view => match Ix.Cli.VerifyCmd.expectedFromManifest singleEnv view 0 with - | .ok (statement, .lift) => + | .ok statement => statement.claim == .checkEnv (canonicalTree #[singleAddr]).root none | _ => false | .error _ => false @@ -1068,7 +1072,8 @@ def joinSmokeSuite : IO UInt32 := do test "coverage accepts legacy zero-constant manifest leaves" singleCoverage, test "empty manifest leaves contract and retained ids remap densely" emptyPruningCorrect, - test "one retained shard folds to a lift root" singleManifestLiftRoot, + 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" diff --git a/Tests/MultiStarkActivation.lean b/Tests/MultiStarkActivation.lean deleted file mode 100644 index a445a13c7..000000000 --- a/Tests/MultiStarkActivation.lean +++ /dev/null @@ -1,532 +0,0 @@ -module - -public import Tests.MultiStark - -/-! -# Aggregate recursion activation audit - -WP-D from `plans/aggregate-first-pipeline.md` asks for an input-shape audit of -the production lift, flat-join, and structural-join entrypoints before any -future static terminal circuit relies on an input-independent activation set. - -This runner deliberately stays separate from the normal aggregate smoke suite. -It executes a deterministic 98-case matrix twice, compares every returned -per-circuit query count, and emits a Markdown report of circuits inactive in at -least one case. It does not add dummy calls; that policy remains deferred until -a static terminal is selected. --/ - -public section - -open Aiur - -namespace Tests.MultiStark -namespace ActivationAudit - -inductive Height where - | short - | tall - deriving BEq, Repr - -private def Height.label : Height → String - | .short => "short" - | .tall => "tall" - -inductive ChildKind where - | lift - | flat - | structural - deriving BEq, Repr - -private def ChildKind.label : ChildKind → String - | .lift => "lift" - | .flat => "flat" - | .structural => "structural" - -inductive Disposition where - | discharge - | carry - deriving BEq, Repr - -private def Disposition.label : Disposition → String - | .discharge => "discharge" - | .carry => "carry" - -inductive Entrypoint where - | lift - | flat - | structural - deriving BEq, Repr - -private def Entrypoint.label : Entrypoint → String - | .lift => "lift" - | .flat => "flat" - | .structural => "structural" - -private inductive JoinKind where - | flat - | structural - -private def JoinKind.entrypoint : JoinKind → Entrypoint - | .flat => .flat - | .structural => .structural - -private def JoinKind.label (kind : JoinKind) : String := - kind.entrypoint.label - -/-- Cheap parameters are sufficient here: the audit studies which verifier -circuits execute, not soundness calibration or proof size. -/ -private def auditFri : Aiur.FriParameters := - { logFinalPolyLen := 0, maxLogArity := 1, numQueries := 1, - commitProofOfWorkBits := 0, queryProofOfWorkBits := 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 - lift : Aiur.Bytecode.FunIdx - flat : Aiur.Bytecode.FunIdx - structural : Aiur.Bytecode.FunIdx - -private structure HeightConfig where - height : Height - fakeIxvmVk : ByteArray - allowed : ByteArray - probeRows : Nat - -/-- Find a tiny fake IxVM key whose own digest and resulting allowed-blob -digest select the same branch of `activation_vary_height`. The search has -roughly 1/4 success probability per candidate for either requested branch. -/ -private def findFakeIxvmVk (childVk : ByteArray) (indices : Indices) - (height : Height) : Except String ByteArray := - let wantShort := height == .short - let candidate? := (Array.range 4096).find? fun n => - let candidate : ByteArray := ⟨Tests.MultiStark.u64le n⟩ - let allowed := MultiStark.allowedBlob candidate indices.verify childVk - indices.lift indices.flat indices.structural - digestSelectsShort (MultiStark.digestGs candidate) == wantShort && - digestSelectsShort (MultiStark.digestGs allowed) == wantShort - match candidate? with - | some n => .ok ⟨Tests.MultiStark.u64le n⟩ - | none => .error s!"activation audit: no {height.label} digest selector found" - -private def heightProbeRows (compiled : Aiur.CompiledToplevel) - (verifyIdx probeIdx : Aiur.Bytecode.FunIdx) (fakeIxvmVk : ByteArray) : - Except String Nat := do - let (_, _, counts) ← compiled.bytecode.execute verifyIdx - (MultiStark.digestGs fakeIxvmVk) default - let some count := counts[probeIdx]? - | throw s!"activation audit: missing height-probe query count {probeIdx}" - pure count.uniqueRows - -private def prepareHeightConfig (compiled : Aiur.CompiledToplevel) - (childVk : ByteArray) (indices : Indices) (probeIdx : Aiur.Bytecode.FunIdx) - (height : Height) : Except String HeightConfig := do - let fakeIxvmVk ← findFakeIxvmVk childVk indices height - let allowed := MultiStark.allowedBlob fakeIxvmVk indices.verify childVk - indices.lift indices.flat indices.structural - let probeRows ← heightProbeRows compiled indices.verify probeIdx fakeIxvmVk - pure { height, fakeIxvmVk, allowed, probeRows } - -private structure PreparedChild where - proofBytes : ByteArray - outerClaimsBytes : ByteArray - preimages : Array ByteArray - -private def prepareChild (system : Aiur.AiurSystem) (indices : Indices) - (config : HeightConfig) (kind : ChildKind) - (statement : MultiStark.CheckEnvTrees) : Except String PreparedChild := do - let claimBytes := Ix.Claim.ser statement.claim - match kind with - | .lift => - let innerClaim := Aiur.buildClaim indices.verify - (MultiStark.digestGs claimBytes) #[] - let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] - let input := MultiStark.verifierPubInput config.fakeIxvmVk innerClaimsBytes - let (outer, proof, _) := system.prove indices.lift input default - let adviceBytes ← system.proofToAdviceBytes outer proof - pure ({ - proofBytes := adviceBytes - outerClaimsBytes := MultiStark.serializeClaims #[outer] - preimages := #[innerClaimsBytes, claimBytes] - } : PreparedChild) - | .flat | .structural => - let idx := match kind with - | .flat => indices.flat - | .structural => indices.structural - | .lift => unreachable! - let input := MultiStark.joinPubInput config.allowed claimBytes - let (outer, proof, _) := system.prove idx input default - let adviceBytes ← system.proofToAdviceBytes outer proof - pure ({ - proofBytes := adviceBytes - outerClaimsBytes := MultiStark.serializeClaims #[outer] - preimages := #[claimBytes] - } : PreparedChild) - -private structure JoinCase where - label : String - allowed : ByteArray - left : MultiStark.CheckEnvTrees - right : MultiStark.CheckEnvTrees - leftChild : PreparedChild - rightChild : PreparedChild - -private def assumptionLabel (present : Bool) : String := - if present then "some" else "none" - -private def selectStatement (withoutAsm discharge carry : - MultiStark.CheckEnvTrees) (present : Bool) - (disposition : Disposition) : MultiStark.CheckEnvTrees := - if !present then withoutAsm - else match disposition with - | .discharge => discharge - | .carry => carry - -/-- Build the 48 join inputs shared by the flat and structural entrypoints: - -`2 heights × 2 dispositions × 2 left-asm shapes × 2 right-asm shapes - × 3 left-child kinds`. - -The right child remains a lift. Both child positions call the same decoder, so -varying one side covers all three decoder arms while retaining a mixed-shape -case for the flat and structural child kinds. -/ -private def prepareJoinCases (system : Aiur.AiurSystem) (indices : Indices) - (configs : Array HeightConfig) : Except String (Array JoinCase) := do - let a := Address.blake3 "activation-subject-left".toUTF8 - let b := Address.blake3 "activation-subject-right".toUTF8 - let c := Address.blake3 "activation-carry-left".toUTF8 - let d := Address.blake3 "activation-carry-right".toUTF8 - let leftSubjects := canonicalTree #[a] - let rightSubjects := canonicalTree #[b] - let leftNone : MultiStark.CheckEnvTrees := - { subjects := leftSubjects, assumptions := none } - let leftDischarge : MultiStark.CheckEnvTrees := - { subjects := leftSubjects, assumptions := some (canonicalTree #[b]) } - let leftCarry : MultiStark.CheckEnvTrees := - { subjects := leftSubjects, assumptions := some (canonicalTree #[c]) } - let rightNone : MultiStark.CheckEnvTrees := - { subjects := rightSubjects, assumptions := none } - let rightDischarge : MultiStark.CheckEnvTrees := - { subjects := rightSubjects, assumptions := some (canonicalTree #[a]) } - let rightCarry : MultiStark.CheckEnvTrees := - { subjects := rightSubjects, assumptions := some (canonicalTree #[d]) } - let mut cases : Array JoinCase := #[] - for config in configs do - for disposition in #[Disposition.discharge, .carry] do - for leftAsm in #[false, true] do - for rightAsm in #[false, true] do - let left := selectStatement leftNone leftDischarge leftCarry - leftAsm disposition - let right := selectStatement rightNone rightDischarge rightCarry - rightAsm disposition - let rightChild ← prepareChild system indices config .lift right - for childKind in #[ChildKind.lift, .flat, .structural] do - let leftChild ← prepareChild system indices config childKind left - cases := cases.push { - label := s!"height={config.height.label},left-asm={assumptionLabel leftAsm},\ - right-asm={assumptionLabel rightAsm},disposition={disposition.label},\ - left-child={childKind.label},right-child=lift" - allowed := config.allowed - left - right - leftChild - rightChild - } - return cases - -private structure Sample where - label : String - entrypoint : Entrypoint - queryCounts : Array Aiur.QueryCount - -private def runLift (compiled : Aiur.CompiledToplevel) - (childSystem : Aiur.AiurSystem) (childVk : ByteArray) (indices : Indices) - (productionLiftIdx : Aiur.Bytecode.FunIdx) (config : HeightConfig) : - Except String Sample := do - let input := MultiStark.digestGs config.fakeIxvmVk - let (innerClaim, proof, _) := childSystem.prove indices.verify input default - let proofBytes ← childSystem.proofToAdviceBytes innerClaim proof - let claimBytes := MultiStark.serializeClaims #[innerClaim] - let pubInput := MultiStark.verifierPubInput childVk claimBytes - let (_, queryCounts) ← compiled.bytecode.executeMultiStark productionLiftIdx - pubInput proofBytes childVk claimBytes - pure { - label := s!"lift/height={config.height.label}" - entrypoint := .lift - queryCounts - } - -private def runJoinWithVk (compiled : Aiur.CompiledToplevel) - (childVk : ByteArray) (flatIdx structuralIdx : Aiur.Bytecode.FunIdx) - (kind : JoinKind) (case : JoinCase) : Except String Sample := do - let output := match kind with - | .flat => case.left.join case.right - | .structural => case.left.joinStructural case.right - let idx := match kind with - | .flat => flatIdx - | .structural => structuralIdx - let trees := match kind with - | .flat => MultiStark.CheckEnvTrees.adviceTrees case.left case.right output - | .structural => - MultiStark.CheckEnvTrees.structuralAdviceTrees case.left case.right output - let paths := match kind with - | .flat => #[] - | .structural => - MultiStark.CheckEnvTrees.structuralPathAdvice case.left case.right output - let outputBytes := Ix.Claim.ser output.claim - let pubInput := MultiStark.joinPubInput case.allowed outputBytes - let preimagesBlob := MultiStark.joinPreimagesBlob - (case.leftChild.preimages ++ case.rightChild.preimages) - let (_, queryCounts) ← match compiled.bytecode.executeMultiStarkJoin idx - pubInput case.leftChild.proofBytes case.rightChild.proofBytes childVk - case.leftChild.outerClaimsBytes case.rightChild.outerClaimsBytes outputBytes - case.allowed preimagesBlob (MultiStark.joinTreesBlob trees) - (MultiStark.joinPathsBlob paths) with - | .ok result => pure result - | .error e => throw s!"{kind.label}/{case.label}: {e}" - pure { - label := s!"{kind.label}/{case.label}" - entrypoint := kind.entrypoint - queryCounts - } - -private def collect (compiled : Aiur.CompiledToplevel) - (childSystem : Aiur.AiurSystem) (childVk : ByteArray) (indices : Indices) - (productionLiftIdx flatIdx structuralIdx : Aiur.Bytecode.FunIdx) - (configs : Array HeightConfig) (cases : Array JoinCase) : - Except String (Array Sample) := do - let mut samples : Array Sample := #[] - for config in configs do - samples := samples.push (← runLift compiled childSystem childVk indices - productionLiftIdx config) - for case in cases do - samples := samples.push (← runJoinWithVk compiled childVk flatIdx - structuralIdx .flat case) - for case in cases do - samples := samples.push (← runJoinWithVk compiled childVk flatIdx - structuralIdx .structural 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.entrypoint == b.entrypoint && - 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 - } - return 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 entrySamples (samples : Array Sample) (entrypoint : Entrypoint) : - Array Sample := - samples.filter fun sample => sample.entrypoint == entrypoint - -private def Cell.render (c : Cell) : String := - if c.active == 0 then s!"0/{c.total}" - else s!"{c.active}/{c.total} ({c.minActiveRows}..{c.maxActiveRows})" - -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 liftSamples := entrySamples samples .lift - let flatSamples := entrySamples samples .flat - let structuralSamples := entrySamples samples .structural - let affected := catalog.filter fun circuit => - let summary := cell samples circuit.queryIdx - summary.active < summary.total - let alwaysActive := catalog.countP fun circuit => - let summary := cell samples circuit.queryIdx - summary.active == summary.total - 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 configRows := configs.map fun config => - s!"| {config.height.label} | {config.probeRows} |" - let circuitRows := affected.map fun circuit => - s!"| `{circuit.name}` | {(cell liftSamples circuit.queryIdx).render} | \ - {(cell flatSamples circuit.queryIdx).render} | \ - {(cell structuralSamples circuit.queryIdx).render} |" - let introduction := #[] - |>.push "# Aggregate recursion activation audit" - |>.push "" - |>.push s!"- Matrix signature: `{activationSignature samples}`" - |>.push s!"- Accepted executions: {samples.size} \ - ({liftSamples.size} lift, {flatSamples.size} flat, \ - {structuralSamples.size} structural)" - |>.push "- Join axes: assumption root `{none,some}` independently per side; \ - `{discharge,carry}`; left child `{lift,flat,structural}` with a lift on \ - the right; and two child trace heights." - |>.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 | `activation_height_probe` unique rows |" - |>.push "|---|---:|" - let circuitHeader := (introduction ++ configRows) - |>.push "" - |>.push "## Circuits inactive in at least one audited shape" - |>.push "" - |>.push "| Circuit | Lift | Flat join | Structural join |" - |>.push "|---|---:|---:|---:|" - String.intercalate "\n" (circuitHeader ++ circuitRows).toList - -def run : IO UInt32 := do - IO.println "aggregate-activation (98-case matrix, two deterministic passes)…" - let childCompiled ← match Tests.MultiStark.joinChildProgram.compile with - | .error e => IO.eprintln s!"activation child compilation failed: {e}"; return 1 - | .ok compiled => pure compiled - let childSystem := Aiur.AiurSystem.build childCompiled.bytecode - Tests.MultiStark.recCommitParams auditFri - let childVk := childSystem.vkBytes - let some verifyIdx := childCompiled.getFuncIdx `fake_verify_claim | do - IO.eprintln "activation audit: fake_verify_claim entrypoint not found"; return 1 - let some childLiftIdx := childCompiled.getFuncIdx `fake_lift | do - IO.eprintln "activation audit: fake_lift entrypoint not found"; return 1 - let some childFlatIdx := childCompiled.getFuncIdx `fake_join | do - IO.eprintln "activation audit: fake_join entrypoint not found"; return 1 - let some childStructuralIdx := childCompiled.getFuncIdx `fake_struct_join | do - IO.eprintln "activation audit: fake_struct_join 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 - lift := childLiftIdx - flat := childFlatIdx - structural := childStructuralIdx - } - let short ← match prepareHeightConfig childCompiled childVk indices probeIdx .short with - | .error e => IO.eprintln e; return 1 - | .ok config => pure config - let tall ← match prepareHeightConfig childCompiled childVk 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 cases ← match prepareJoinCases childSystem indices configs with - | .error e => IO.eprintln s!"activation audit input preparation failed: {e}"; return 1 - | .ok cases => pure cases - if cases.size != 48 then - IO.eprintln s!"activation audit: expected 48 join cases, built {cases.size}" - return 1 - - let top ← match MultiStark.multiStark 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 productionLiftIdx := compiled.getFuncIdx `verify_multi_stark_proof | do - IO.eprintln "activation audit: production lift entrypoint not found"; return 1 - let some flatIdx := compiled.getFuncIdx `join_two | do - IO.eprintln "activation audit: flat join entrypoint not found"; return 1 - let some structuralIdx := compiled.getFuncIdx `join_two_structural | do - IO.eprintln "activation audit: structural join entrypoint not found"; return 1 - - let first ← match collect compiled childSystem childVk indices - productionLiftIdx flatIdx structuralIdx configs cases with - | .error e => IO.eprintln s!"activation audit pass 1 failed: {e}"; return 1 - | .ok samples => pure samples - let second ← match collect compiled childSystem childVk indices - productionLiftIdx flatIdx structuralIdx configs cases with - | .error e => IO.eprintln s!"activation audit pass 2 failed: {e}"; return 1 - | .ok samples => pure samples - if first.size != 98 then - IO.eprintln s!"activation audit: expected 98 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.MultiStark - -end diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 093db49eb..ede0b0445 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -1262,15 +1262,18 @@ fn build_ix_aggr_io_buffer( allowed: &[u8], preimages_blob: &[u8], trees_blob: &[u8], + paths_blob: &[u8], ) -> Result { use ixvm_codegen::aiur_ix_aggr_runner::{ - AggrAdvice, aggr_io_buffer, decode_aggr_preimages, decode_aggr_trees, + 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], @@ -1281,6 +1284,7 @@ fn build_ix_aggr_io_buffer( allowed, preimages: &preimages, trees: &trees, + paths: &paths, })) } @@ -1307,6 +1311,7 @@ extern "C" fn rs_aiur_ix_aggr_execute( allowed_bytes: LeanByteArray>, preimages_blob: LeanByteArray>, trees_blob: LeanByteArray>, + paths_blob: LeanByteArray>, use_bytecode: bool, ) -> LeanExcept { let toplevel = decode_toplevel(&toplevel); @@ -1323,6 +1328,7 @@ extern "C" fn rs_aiur_ix_aggr_execute( 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), @@ -1369,6 +1375,7 @@ extern "C" fn rs_aiur_ix_aggr_prove( allowed_bytes: LeanByteArray>, preimages_blob: LeanByteArray>, trees_blob: LeanByteArray>, + paths_blob: LeanByteArray>, use_bytecode: bool, ) -> LeanExcept { let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); @@ -1384,6 +1391,7 @@ extern "C" fn rs_aiur_ix_aggr_prove( 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), diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr.rs b/crates/ixvm-codegen/src/aiur_ix_aggr.rs index df574bfeb..d9e1fcf63 100644 --- a/crates/ixvm-codegen/src/aiur_ix_aggr.rs +++ b/crates/ixvm-codegen/src/aiur_ix_aggr.rs @@ -5161,7 +5161,7 @@ fn aiur_fn_72( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; 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 __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]; @@ -5342,10 +5342,10 @@ fn aiur_fn_72( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; 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 __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_228] = { let __args: [G; IN_228] = [__v_0]; 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 __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]; @@ -9731,7 +9731,7 @@ fn aiur_fn_97( 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_232] = { let __args: [G; IN_232] = [__v_87, __v_155]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); }; @@ -11430,7 +11430,7 @@ fn aiur_fn_113( 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_227] = { let __args: [G; IN_227] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -12288,7 +12288,7 @@ fn aiur_fn_126( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -12581,7 +12581,7 @@ fn aiur_fn_131( 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_234] = { let __args: [G; IN_234] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)? } }; @@ -12620,9 +12620,9 @@ fn aiur_fn_131( 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_236] = { let __args: [G; IN_236] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_231] = { let __args: [G; IN_231] = [__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 __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)); @@ -12660,10 +12660,10 @@ fn aiur_fn_132( 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_227] = { let __args: [G; IN_227] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -12716,12 +12716,12 @@ fn aiur_fn_133( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -12769,15 +12769,15 @@ fn aiur_fn_134( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -12827,7 +12827,7 @@ fn aiur_fn_135( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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() { @@ -12843,12 +12843,12 @@ fn aiur_fn_135( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -12906,7 +12906,7 @@ fn aiur_fn_136( }, 1u64 => { let __v_15: G = G::from_u64(3); - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1, __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 __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() { @@ -12916,9 +12916,9 @@ fn aiur_fn_136( 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_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 __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_239] = { let __args: [G; IN_239] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -12927,7 +12927,7 @@ fn aiur_fn_136( 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_234] = { let __args: [G; IN_234] = [__v_8, __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 __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]; @@ -12977,7 +12977,7 @@ fn aiur_fn_137( }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -13066,7 +13066,7 @@ fn aiur_fn_139( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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() { @@ -13083,7 +13083,7 @@ fn aiur_fn_139( }, 1u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -13495,7 +13495,7 @@ fn aiur_fn_143( 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_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 __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) { @@ -13530,7 +13530,7 @@ fn aiur_fn_143( 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_229] = { let __args: [G; IN_229] = [__v_11, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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() { @@ -13645,7 +13645,7 @@ fn aiur_fn_143( 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_231] = { let __args: [G; IN_231] = [__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 __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) { @@ -13884,7 +13884,7 @@ fn aiur_fn_144( 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_229] = { let __args: [G; IN_229] = [__v_1, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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() { @@ -13893,7 +13893,7 @@ fn aiur_fn_144( 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_229] = { let __args: [G; IN_229] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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() { @@ -13902,7 +13902,7 @@ fn aiur_fn_144( 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_229] = { let __args: [G; IN_229] = [__v_1, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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() { @@ -13930,10 +13930,10 @@ fn aiur_fn_144( 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_229] = { let __args: [G; IN_229] = [__v_23, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_230] = { let __args: [G; IN_230] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -13941,7 +13941,7 @@ fn aiur_fn_144( 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_231] = { let __args: [G; IN_231] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)? } }; @@ -13953,7 +13953,7 @@ fn aiur_fn_144( 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_239] = { let __args: [G; IN_239] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -13967,7 +13967,7 @@ fn aiur_fn_144( 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_239] = { let __args: [G; IN_239] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -13981,7 +13981,7 @@ fn aiur_fn_144( 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_239] = { let __args: [G; IN_239] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -14142,7 +14142,7 @@ fn aiur_fn_146( let __v_30: G = inp[30]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -14168,7 +14168,7 @@ fn aiur_fn_146( 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_233] = { let __args: [G; IN_233] = [__v_0, __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 __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); @@ -14242,7 +14242,7 @@ fn aiur_fn_146( 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_233] = { let __args: [G; IN_233] = [__v_104, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -14250,7 +14250,7 @@ fn aiur_fn_146( 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_236] = { let __args: [G; IN_236] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -14258,7 +14258,7 @@ fn aiur_fn_146( 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_231] = { let __args: [G; IN_231] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -14266,7 +14266,7 @@ fn aiur_fn_146( 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_231] = { let __args: [G; IN_231] = [__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 __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) { @@ -15145,7 +15145,7 @@ fn aiur_fn_158( 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_233] = { let __args: [G; IN_233] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); }; @@ -15170,7 +15170,7 @@ fn aiur_fn_159( 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_233] = { let __args: [G; IN_233] = [__v_0, __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 __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)); }; @@ -15415,7 +15415,7 @@ fn aiur_fn_163( 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_233] = { let __args: [G; IN_233] = [__v_75, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -15446,7 +15446,7 @@ fn aiur_fn_163( 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_233] = { let __args: [G; IN_233] = [__v_102, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -15455,7 +15455,7 @@ fn aiur_fn_163( 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_233] = { let __args: [G; IN_233] = [__v_110, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -15987,24 +15987,24 @@ fn aiur_fn_169( let __v_22: G = inp[22]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__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 __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_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 __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_239] = { let __args: [G; IN_239] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_239] = { let __args: [G; IN_239] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 }); @@ -16169,7 +16169,7 @@ fn aiur_fn_173( let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; - 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 __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]; @@ -16186,7 +16186,7 @@ fn aiur_fn_173( let __v_20: G = (__v_16 + __v_19); match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -16194,7 +16194,7 @@ fn aiur_fn_173( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -16202,7 +16202,7 @@ fn aiur_fn_173( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -16210,7 +16210,7 @@ fn aiur_fn_173( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -16218,7 +16218,7 @@ fn aiur_fn_173( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -16226,7 +16226,7 @@ fn aiur_fn_173( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -16236,7 +16236,7 @@ fn aiur_fn_173( } }, 2u64 => { - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -16638,23 +16638,23 @@ fn aiur_fn_177( match __v_88.as_canonical_u64() { 0u64 => { let __v_89: G = (__v_7 + __v_7); - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_35, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_35, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_36, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_36, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -16688,25 +16688,25 @@ fn aiur_fn_177( match __v_90.as_canonical_u64() { 0u64 => { let __v_91: G = (__v_7 + __v_7); - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_35, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_35, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_35, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_35, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -16869,11 +16869,11 @@ fn aiur_fn_178( match __v_78.as_canonical_u64() { 1u64 => { let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_9, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_8, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -16884,11 +16884,11 @@ fn aiur_fn_178( 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_229] = { let __args: [G; IN_229] = [__v_9, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_8, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -16904,7 +16904,7 @@ fn aiur_fn_178( }, 0u64 => { let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -17211,13 +17211,13 @@ fn aiur_fn_182( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); }; @@ -17284,30 +17284,30 @@ fn aiur_fn_183( 0u64 => { match __v_21.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_37, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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() { @@ -17332,13 +17332,13 @@ fn aiur_fn_183( break '__mc_0 [__v_46, __v_49]; }, 1u64 => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; }, @@ -17577,11 +17577,11 @@ fn aiur_fn_183( 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_229] = { let __args: [G; IN_229] = [__v_41, __v_230]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_39, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -17592,11 +17592,11 @@ fn aiur_fn_183( 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_229] = { let __args: [G; IN_229] = [__v_41, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_229] = { let __args: [G; IN_229] = [__v_39, __v_245]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -17610,7 +17610,7 @@ fn aiur_fn_183( }, 0u64 => { let __v_230: G = G::from_u64(0); - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -17633,10 +17633,10 @@ fn aiur_fn_183( }; let __v_230: G = __mc_out___mc_1[0]; let __v_231: G = __mc_out___mc_1[1]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_227] = { let __args: [G; IN_227] = [__v_232, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -17662,7 +17662,7 @@ fn aiur_fn_183( 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_231] = { let __args: [G; IN_231] = [__v_235]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -18003,7 +18003,7 @@ fn aiur_fn_186( 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_233] = { let __args: [G; IN_233] = [__v_106, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -18034,7 +18034,7 @@ fn aiur_fn_186( 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_233] = { let __args: [G; IN_233] = [__v_133, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -18043,7 +18043,7 @@ fn aiur_fn_186( 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_233] = { let __args: [G; IN_233] = [__v_141, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -18267,11 +18267,11 @@ fn aiur_fn_186( 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_238] = { let __args: [G; IN_238] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_239] = { let __args: [G; IN_239] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -18297,7 +18297,7 @@ fn aiur_fn_186( 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_233] = { let __args: [G; IN_233] = [__v_188, __v_372]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -18371,7 +18371,7 @@ fn aiur_fn_186( 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_233] = { let __args: [G; IN_233] = [__v_438, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -18385,9 +18385,9 @@ fn aiur_fn_186( 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_239] = { let __args: [G; IN_239] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_238] = { let __args: [G; IN_238] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -18395,9 +18395,9 @@ fn aiur_fn_186( 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_238] = { let __args: [G; IN_238] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_231] = { let __args: [G; IN_231] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -18405,7 +18405,7 @@ fn aiur_fn_186( 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_236] = { let __args: [G; IN_236] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -18413,7 +18413,7 @@ fn aiur_fn_186( 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_231] = { let __args: [G; IN_231] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -18421,7 +18421,7 @@ fn aiur_fn_186( 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_231] = { let __args: [G; IN_231] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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) { @@ -19959,7 +19959,7 @@ fn aiur_fn_202( 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_233] = { let __args: [G; IN_233] = [__v_3, __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 __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)); }; @@ -20257,7 +20257,7 @@ fn aiur_fn_207( 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_228] = { let __args: [G; IN_228] = [__v_40]; 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 __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) { @@ -20694,15 +20694,284 @@ fn aiur_fn_213( }) } -const INPUT_SIZE_214: usize = 1; -const IN_214: usize = 1; -const OUT_214: usize = 3; +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)? } }; @@ -20712,8 +20981,8 @@ fn aiur_fn_214( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_214] = [__v_3, __v_4, __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)); }; + 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 => { @@ -20721,8 +20990,8 @@ fn aiur_fn_214( 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_214] = [__v_5, __v_3, __v_4]; - if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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); }, _ => { @@ -20732,15 +21001,15 @@ fn aiur_fn_214( }) } -const INPUT_SIZE_215: usize = 1; -const IN_215: usize = 1; -const OUT_215: usize = 3; -fn aiur_fn_215( - inp: [G; IN_215], +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_215], ExecError> { +) -> 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)? } }; @@ -20749,7 +21018,7 @@ fn aiur_fn_215( 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_214] = { let __args: [G; IN_214] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -20772,21 +21041,21 @@ fn aiur_fn_215( 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_215] = [__v_3, __v_5, __v_6]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_216: usize = 8; -const IN_216: usize = 8; -const OUT_216: usize = 1; -fn aiur_fn_216( - inp: [G; IN_216], +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_216], ExecError> { +) -> 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]; @@ -20984,25 +21253,25 @@ fn aiur_fn_216( 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_216] = [__v_12]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_217: usize = 2; -const IN_217: usize = 2; -const OUT_217: usize = 1; -fn aiur_fn_217( - inp: [G; IN_217], +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_217], ExecError> { +) -> 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_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 __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]; @@ -21032,69 +21301,69 @@ fn aiur_fn_217( 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_217] = [__v_30]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_218: usize = 2; -const IN_218: usize = 2; -const OUT_218: usize = 8; -fn aiur_fn_218( - inp: [G; IN_218], +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_218], ExecError> { +) -> 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_217] = { let __args: [G; IN_217] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_0, __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 __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_217] = { let __args: [G; IN_217] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_0, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_218] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_219: usize = 16; -const IN_219: usize = 16; -const OUT_219: usize = 0; -fn aiur_fn_219( - inp: [G; IN_219], +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_219], ExecError> { +) -> 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]; @@ -21136,21 +21405,21 @@ fn aiur_fn_219( 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_219] = []; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_220: usize = 1; -const IN_220: usize = 1; -const OUT_220: usize = 1; -fn aiur_fn_220( - inp: [G; IN_220], +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_220], ExecError> { +) -> 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 }; @@ -21174,8 +21443,8 @@ fn aiur_fn_220( 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_220] = [__v_2]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -21185,15 +21454,15 @@ fn aiur_fn_220( }) } -const INPUT_SIZE_221: usize = 17; -const IN_221: usize = 17; -const OUT_221: usize = 12; -fn aiur_fn_221( - inp: [G; IN_221], +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_221], ExecError> { +) -> 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]; @@ -21378,11 +21647,11 @@ fn aiur_fn_221( 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_219] = { let __args: [G; IN_219] = [__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[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_219] = { let __args: [G; IN_219] = [__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[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 []; }, } @@ -21564,7 +21833,7 @@ fn aiur_fn_221( 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_232] = { let __args: [G; IN_232] = [__v_263, __v_331]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -21581,21 +21850,21 @@ fn aiur_fn_221( 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_221] = [__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[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_222: usize = 13; -const IN_222: usize = 13; -const OUT_222: usize = 1; -fn aiur_fn_222( - inp: [G; IN_222], +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_222], ExecError> { +) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21694,7 +21963,7 @@ fn aiur_fn_222( let __v_70: G = __r_arr[1]; match __v_18.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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() { _ => { @@ -21805,7 +22074,7 @@ fn aiur_fn_222( 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_233] = { let __args: [G; IN_233] = [__v_141, __v_147]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -21836,7 +22105,7 @@ fn aiur_fn_222( 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_233] = { let __args: [G; IN_233] = [__v_168, __v_174]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -21845,7 +22114,7 @@ fn aiur_fn_222( 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_233] = { let __args: [G; IN_233] = [__v_176, __v_180]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -22069,11 +22338,11 @@ fn aiur_fn_222( 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_238] = { let __args: [G; IN_238] = [__v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_239] = { let __args: [G; IN_239] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -22099,7 +22368,7 @@ fn aiur_fn_222( 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_233] = { let __args: [G; IN_233] = [__v_223, __v_407]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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); @@ -22173,7 +22442,7 @@ fn aiur_fn_222( 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_233] = { let __args: [G; IN_233] = [__v_473, __v_477]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -22205,17 +22474,17 @@ fn aiur_fn_222( 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_239] = { let __args: [G; IN_239] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_239] = { let __args: [G; IN_239] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_239] = { let __args: [G; IN_239] = [__v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 }); @@ -22237,9 +22506,9 @@ fn aiur_fn_222( 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_239] = { let __args: [G; IN_239] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_238] = { let __args: [G; IN_238] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -22247,9 +22516,9 @@ fn aiur_fn_222( 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_238] = { let __args: [G; IN_238] = [__v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_231] = { let __args: [G; IN_231] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -22257,7 +22526,7 @@ fn aiur_fn_222( 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_236] = { let __args: [G; IN_236] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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)); @@ -22265,7 +22534,7 @@ fn aiur_fn_222( 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_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 __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)); @@ -22273,7 +22542,7 @@ fn aiur_fn_222( 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_231] = { let __args: [G; IN_231] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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) { @@ -22291,8 +22560,8 @@ fn aiur_fn_222( 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_222] = [__v_69]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, } @@ -22309,15 +22578,15 @@ fn aiur_fn_222( }) } -const INPUT_SIZE_223: usize = 28; -const IN_223: usize = 28; -const OUT_223: usize = 8; -fn aiur_fn_223( - inp: [G; IN_223], +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_223], ExecError> { +) -> 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]; @@ -22347,7 +22616,7 @@ fn aiur_fn_223( let __v_25: G = inp[25]; let __v_26: G = inp[26]; let __v_27: G = inp[27]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__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[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -22360,12 +22629,12 @@ fn aiur_fn_223( 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_222] = { let __args: [G; IN_222] = [__v_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[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_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_220] = { let __args: [G; IN_220] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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) { @@ -22373,20 +22642,20 @@ fn aiur_fn_223( } match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_41, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_218] = { let __args: [G; IN_218] = [__v_41, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -22395,13 +22664,13 @@ fn aiur_fn_223( 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_223] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_218] = { let __args: [G; IN_218] = [__v_41, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -22410,21 +22679,21 @@ fn aiur_fn_223( 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_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[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_41, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_218] = { let __args: [G; IN_218] = [__v_41, __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 __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]; @@ -22433,23 +22702,23 @@ fn aiur_fn_223( 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_223] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_224: usize = 35; -const IN_224: usize = 35; -const OUT_224: usize = 0; -fn aiur_fn_224( - inp: [G; IN_224], +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_224], 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]; @@ -22487,7 +22756,7 @@ fn aiur_fn_224( 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_223] = { let __args: [G; IN_223] = [__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[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -22496,22 +22765,22 @@ fn aiur_fn_224( 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_219] = { let __args: [G; IN_219] = [__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[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_224] = []; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_225: usize = 36; -const IN_225: usize = 36; -const OUT_225: usize = 0; -fn aiur_fn_225( - inp: [G; IN_225], +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_225], ExecError> { +) -> 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]; @@ -22550,7 +22819,7 @@ fn aiur_fn_225( 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_223] = { let __args: [G; IN_223] = [__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[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -22560,7 +22829,7 @@ fn aiur_fn_225( 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_223] = { let __args: [G; IN_223] = [__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[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -22569,15 +22838,15 @@ fn aiur_fn_225( 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_216] = { let __args: [G; IN_216] = [__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[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_215] = { let __args: [G; IN_215] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_216] = { let __args: [G; IN_216] = [__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[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_215] = { let __args: [G; IN_215] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -22674,7 +22943,7 @@ fn aiur_fn_225( 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_215] = { let __args: [G; IN_215] = [__v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -22788,21 +23057,21 @@ fn aiur_fn_225( 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_225] = []; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_226: usize = 16; -const IN_226: usize = 16; -const OUT_226: usize = 0; -fn aiur_fn_226( - inp: [G; IN_226], +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_226], ExecError> { +) -> 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]; @@ -22820,20 +23089,312 @@ fn aiur_fn_226( 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_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); @@ -23137,48 +23698,80 @@ fn aiur_fn_226( match __v_165.as_canonical_u64() { 0u64 => { let __v_251: G = G::from_u64(0); - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__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[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 __ret: [G; OUT_226] = []; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_224] = { let __args: [G; IN_224] = [__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[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 __ret: [G; OUT_226] = []; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_225] = { let __args: [G; IN_225] = [__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[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 __ret: [G; OUT_226] = []; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_225] = { let __args: [G; IN_225] = [__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[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 __ret: [G; OUT_226] = []; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_225] = { let __args: [G; IN_225] = [__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[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 __ret: [G; OUT_226] = []; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_225] = { let __args: [G; IN_225] = [__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[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 __ret: [G; OUT_226] = []; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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); }, _ => { @@ -23188,19 +23781,19 @@ fn aiur_fn_226( }) } -const INPUT_SIZE_227: usize = 2; -const IN_227: usize = 2; -const OUT_227: usize = 1; -fn aiur_fn_227( - inp: [G; IN_227], +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_227], ExecError> { +) -> 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_234] = { let __args: [G; IN_234] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -23208,8 +23801,8 @@ fn aiur_fn_227( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_227] = [__v_4]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23219,15 +23812,15 @@ fn aiur_fn_227( }) } -const INPUT_SIZE_228: usize = 1; -const IN_228: usize = 1; -const OUT_228: usize = 1; -fn aiur_fn_228( - inp: [G; IN_228], +const INPUT_SIZE_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_228], ExecError> { +) -> 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 }; @@ -23237,14 +23830,14 @@ fn aiur_fn_228( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_228] = [__v_4]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_228] = [__v_4]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23254,19 +23847,19 @@ fn aiur_fn_228( }) } -const INPUT_SIZE_229: usize = 2; -const IN_229: usize = 2; -const OUT_229: usize = 2; -fn aiur_fn_229( - inp: [G; IN_229], +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_229], ExecError> { +) -> 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_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 __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]; @@ -23275,8 +23868,8 @@ fn aiur_fn_229( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_229] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23286,15 +23879,15 @@ fn aiur_fn_229( }) } -const INPUT_SIZE_230: usize = 1; -const IN_230: usize = 1; -const OUT_230: usize = 1; -fn aiur_fn_230( - inp: [G; IN_230], +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_230], ExecError> { +) -> 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 }; @@ -23306,17 +23899,17 @@ fn aiur_fn_230( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_230] = [__v_6]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_230] = { let __args: [G; IN_230] = [__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 __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_230] = [__v_8]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23326,15 +23919,15 @@ fn aiur_fn_230( }) } -const INPUT_SIZE_231: usize = 1; -const IN_231: usize = 1; -const OUT_231: usize = 1; -fn aiur_fn_231( - inp: [G; IN_231], +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_231], ExecError> { +) -> 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 }; @@ -23345,17 +23938,17 @@ fn aiur_fn_231( match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_231] = [__v_5]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_231] = { let __args: [G; IN_231] = [__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 __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_231] = [__v_7]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23365,15 +23958,15 @@ fn aiur_fn_231( }) } -const INPUT_SIZE_232: usize = 2; -const IN_232: usize = 2; -const OUT_232: usize = 1; -fn aiur_fn_232( - inp: [G; IN_232], +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_232], 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]; @@ -23390,17 +23983,17 @@ fn aiur_fn_232( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_232] = [__v_1]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_232] = { let __args: [G; IN_232] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_232] = [__v_14]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23410,15 +24003,15 @@ fn aiur_fn_232( }) } -const INPUT_SIZE_233: usize = 2; -const IN_233: usize = 2; -const OUT_233: usize = 1; -fn aiur_fn_233( - inp: [G; IN_233], +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_233], 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]; @@ -23428,17 +24021,17 @@ fn aiur_fn_233( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_233] = [__v_1]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_233] = [__v_7]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23448,28 +24041,28 @@ fn aiur_fn_233( }) } -const INPUT_SIZE_234: usize = 2; -const IN_234: usize = 2; -const OUT_234: usize = 1; -fn aiur_fn_234( - inp: [G; IN_234], +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_234], ExecError> { +) -> 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_234] = [__v_0]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_234] = { let __args: [G; IN_234] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -23477,8 +24070,8 @@ fn aiur_fn_234( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - 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)); }; + 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); }, _ => { @@ -23490,15 +24083,15 @@ fn aiur_fn_234( }) } -const INPUT_SIZE_235: usize = 1; -const IN_235: usize = 1; -const OUT_235: usize = 1; -fn aiur_fn_235( - inp: [G; IN_235], +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_235], ExecError> { +) -> 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 }; @@ -23512,17 +24105,17 @@ fn aiur_fn_235( match __v_1.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_235] = [__v_8]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_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 __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_235] = [__v_10]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23532,15 +24125,15 @@ fn aiur_fn_235( }) } -const INPUT_SIZE_236: usize = 1; -const IN_236: usize = 1; -const OUT_236: usize = 1; -fn aiur_fn_236( - inp: [G; IN_236], +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_236], ExecError> { +) -> 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 }; @@ -23557,17 +24150,17 @@ fn aiur_fn_236( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_11]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_236] = { let __args: [G; IN_236] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_236] = [__v_13]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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); }, _ => { @@ -23577,19 +24170,19 @@ fn aiur_fn_236( }) } -const INPUT_SIZE_237: usize = 2; -const IN_237: usize = 2; -const OUT_237: usize = 4; -fn aiur_fn_237( - inp: [G; IN_237], +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_237], ExecError> { +) -> 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_242] = { let __args: [G; IN_242] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -23600,8 +24193,8 @@ fn aiur_fn_237( let __v_8: G = __loaded[5]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_237] = [__v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23611,15 +24204,15 @@ fn aiur_fn_237( }) } -const INPUT_SIZE_238: usize = 1; -const IN_238: usize = 1; -const OUT_238: usize = 1; -fn aiur_fn_238( - inp: [G; IN_238], +const INPUT_SIZE_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_238], ExecError> { +) -> 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 }; @@ -23634,17 +24227,17 @@ fn aiur_fn_238( match __v_1.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_238] = [__v_9]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_238] = { let __args: [G; IN_238] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_238] = [__v_11]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23654,15 +24247,15 @@ fn aiur_fn_238( }) } -const INPUT_SIZE_239: usize = 1; -const IN_239: usize = 1; -const OUT_239: usize = 1; -fn aiur_fn_239( - inp: [G; IN_239], +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_239], ExecError> { +) -> 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 }; @@ -23672,17 +24265,17 @@ fn aiur_fn_239( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_239] = [__v_4]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_239] = { let __args: [G; IN_239] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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_239] = [__v_6]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23692,19 +24285,19 @@ fn aiur_fn_239( }) } -const INPUT_SIZE_240: usize = 2; -const IN_240: usize = 2; -const OUT_240: usize = 8; -fn aiur_fn_240( - inp: [G; IN_240], +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_240], ExecError> { +) -> 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_243] = { let __args: [G; IN_243] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -23719,8 +24312,8 @@ fn aiur_fn_240( let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_240] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23730,28 +24323,28 @@ fn aiur_fn_240( }) } -const INPUT_SIZE_241: usize = 2; -const IN_241: usize = 2; -const OUT_241: usize = 1; -fn aiur_fn_241( - inp: [G; IN_241], +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_241], 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_241] = [__v_0]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_241] = { let __args: [G; IN_241] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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]; @@ -23760,8 +24353,8 @@ fn aiur_fn_241( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_241] = [__v_8]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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); }, _ => { @@ -23773,28 +24366,28 @@ fn aiur_fn_241( }) } -const INPUT_SIZE_242: usize = 2; -const IN_242: usize = 2; -const OUT_242: usize = 1; -fn aiur_fn_242( - inp: [G; IN_242], +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_242], ExecError> { +) -> 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_242] = [__v_0]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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_242] = { let __args: [G; IN_242] = [__v_0, __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 __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]; @@ -23805,8 +24398,8 @@ fn aiur_fn_242( let __v_10: G = __loaded[5]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_242] = [__v_10]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_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); }, _ => { @@ -23818,28 +24411,28 @@ fn aiur_fn_242( }) } -const INPUT_SIZE_243: usize = 2; -const IN_243: usize = 2; -const OUT_243: usize = 1; -fn aiur_fn_243( - inp: [G; IN_243], +const INPUT_SIZE_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_243], ExecError> { +) -> 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_243] = [__v_0]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_243] = { let __args: [G; IN_243] = [__v_0, __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 __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]; @@ -23854,8 +24447,8 @@ fn aiur_fn_243( let __v_14: G = __loaded[9]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_243] = [__v_14]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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); }, _ => { @@ -25094,6 +25687,26 @@ pub(crate) fn execute_generated( 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 index 6a6a4ef81..81ca667e9 100644 --- a/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs +++ b/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs @@ -37,6 +37,15 @@ pub struct AggrTree<'a> { 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 @@ -54,6 +63,7 @@ pub struct AggrAdvice<'a> { 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 @@ -78,6 +88,18 @@ pub fn decode_aggr_trees(blob: &[u8]) -> Result>, String> { }) } +/// 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>, 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, @@ -209,7 +231,8 @@ pub fn execute_ix_aggr( /// * 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 `[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() }; @@ -235,6 +258,14 @@ pub fn aggr_io_buffer(advice: &AggrAdvice<'_>) -> IOBuffer { 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 } @@ -269,6 +300,7 @@ mod tests { } 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]], @@ -279,6 +311,7 @@ mod tests { allowed: &[10], preimages: &preimages, trees: &trees, + paths: &paths, }; let io = aggr_io_buffer(&advice); @@ -299,8 +332,9 @@ mod tests { 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]); + 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)); } @@ -322,8 +356,13 @@ mod tests { 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/lakefile.lean b/lakefile.lean index fbd074f59..0c244aa3a 100644 --- a/lakefile.lean +++ b/lakefile.lean @@ -154,6 +154,10 @@ lean_exe «bench-recursion-debug» where lean_exe «bench-aggregate-pair» where root := `Benchmarks.AggregatePair 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 From b70042d6d1a029bb8e1d541da7aef5e0613d67e6 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Sat, 29 Aug 2026 10:25:39 -0400 Subject: [PATCH 24/44] bench: add converged aggregate policy handoff Replace the legacy two-shard three-entrypoint benchmark with a four-shard manifest-subtree harness for production ix_aggr wrap-first and direct policies. Enforce the q=100 serialized no-cache profile, natively verify every input and recursive output, persist ordinary aggregate wrappers, and emit resumable per-slot JSON metrics. Port bench-typecheck --join to ix_aggr direct shape 2 while preserving the stable join metric schema. Remove the final legacy slot-spec/preimage shim and pin both M1-f four-shard plans in the focused suite. --- Benchmarks/AggregatePair.lean | 711 ----------------------------- Benchmarks/AggregatePolicy.lean | 764 ++++++++++++++++++++++++++++++++ Benchmarks/Typecheck.lean | 127 +++--- Ix/Cli/AggregateCmd.lean | 69 +-- Tests/Aggr.lean | 28 ++ Tests/MultiStark.lean | 58 +-- lakefile.lean | 4 +- 7 files changed, 888 insertions(+), 873 deletions(-) delete mode 100644 Benchmarks/AggregatePair.lean create mode 100644 Benchmarks/AggregatePolicy.lean diff --git a/Benchmarks/AggregatePair.lean b/Benchmarks/AggregatePair.lean deleted file mode 100644 index cab3975fc..000000000 --- a/Benchmarks/AggregatePair.lean +++ /dev/null @@ -1,711 +0,0 @@ -import Ix.Cli.AggregateCmd -import Ix.Cli.NameResolve -import Ix.TracingTexray -import Ix.Benchmark.Bench - -/-! -# Two-shard end-to-end production aggregation benchmark - -This is deliberately a benchmark executable rather than a production CLI -mode. It can select two shards from a validated `.ixes` manifest and benchmark -the complete proof path: - -``` -shard A -> IxVM proof A -> recursive lift A ---+ - +-> structural/flat join -> verify -shard B -> IxVM proof B -> recursive lift B ---+ -``` - -Unlike `ix aggregate`, the result is allowed to retain assumptions and need -not cover the whole environment. It therefore cannot be mistaken for a closed -full-environment aggregate. - -With no arguments it reads `init.ixe` and treats the `False` and `True` block -groups as two conditional micro-shards. They exercise the real Init environment -and production proof stack without inheriting the memory footprint of a full -RAM-planned shard. `--ixes` switches to a complete manifest and automatically -chooses its smallest direct sibling pair. Supplying `--shard-a` and `--shard-b` -instead selects any two nonempty shards from that manifest; they need not be -siblings: - -``` -lake exe bench-aggregate-pair -- \ - --ixe /path/init.ixe --name-a False --name-b True \ - --json /tmp/init-pair.json --texray - -lake exe bench-aggregate-pair -- \ - --ixe /path/init.ixe --ixes /path/init.ixes \ - --shard-a 3 --shard-b 17 --json /tmp/init-real-pair.json -``` - -`--proof-a` and `--proof-b` may be supplied together to reuse persisted base -proofs. They are an explicit warm-start mode; the default always measures base -proving as well as recursive aggregation. - -Every stage is the real production proof call, with no execution-only preflight -or memory gate. Like `bench-typecheck --recursive`, the default benchmark -profile uses 50 FRI queries and zero query PoW for both base and recursive -proofs; `--queries` can override the count. Timings and measured peak RSS are -recorded after the fact. --/ - -open Lean (Json) - -namespace Benchmarks.AggregatePair - -open Ix -open Ix.Cli.AggregateCmd - -abbrev AggregationTree := Ix.Cli.CheckCmd.AggregationTree -abbrev FoldOp := Ix.Cli.CheckCmd.AggregationTree.FoldOp - -/-- Keep this in lockstep with `Benchmarks.Typecheck.recursiveFriParameters`. -The benchmark measures the full recursive architecture under the repository's -established tractable recursion profile, not the 100-query production policy. -/ -def benchmarkFriParameters (queries : Nat) : Aiur.FriParameters := { - logFinalPolyLen := 0 - maxLogArity := 1 - numQueries := queries - commitProofOfWorkBits := 0 - queryProofOfWorkBits := 0 -} - -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 stageJson (fields : List (String × Json)) : Json := - Json.mkObj (("status", Json.str "ok") :: fields) - -def errorJson (message : String) : Json := - Json.mkObj [("status", Json.str "error"), ("message", Json.str message)] - -def writeReport (path? : Option String) (metadata : List (String × Json)) - (status : String) (stages : Array (String × Json)) : IO Unit := do - if let some path := path? then - let report := Json.mkObj (metadata ++ - [("status", Json.str status), ("stages", Json.mkObj stages.toList)]) - IO.FS.writeFile path (report.pretty ++ "\n") - -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 } - -def blockOfAddress (env : Ixon.Env) (address : Address) : Except String Address := do - let some constant := env.getConst? address - | throw s!"constant {address} is absent or malformed" - pure <| match constant.info with - | .iPrj projection => projection.block - | .cPrj projection => projection.block - | .rPrj projection => projection.block - | .dPrj projection => projection.block - | _ => address - -def namedMicroShard (env : Ixon.Env) (name : String) : - Except String (Array Address) := do - let some address := Ix.Cli.NameResolve.resolveIxeAddr env name - | throw s!"Init micro-shard name not found: {name}" - pure #[← blockOfAddress env address] - -partial def siblingLeafPairs (tree : AggregationTree) : Array (Nat × Nat) := - match tree with - | .leaf _ => #[] - | .node left right => - let here := match left, right with - | .leaf l, .leaf r => #[(l, r)] - | _, _ => #[] - here ++ siblingLeafPairs left ++ siblingLeafPairs right - -/-- The smallest direct sibling pair by combined subject count. The manifest -tree and count array have already passed coverage/pruning validation. -/ -def smallestSiblingPair? (tree : AggregationTree) (counts : Array Nat) : - Option (Nat × Nat) := - (siblingLeafPairs tree).foldl (init := none) fun best pair => - match best with - | none => some pair - | some current => - let pairCount := counts[pair.1]! + counts[pair.2]! - let currentCount := counts[current.1]! + counts[current.2]! - if pairCount < currentCount then some pair else some current - -def loadProofWrapper (label proofAddress : String) : IO (Except String Ixon.Proof) := do - let some address := Address.fromString proofAddress - | return .error s!"{label}: expected a 64-character store address" - try - match Ixon.Proof.de (← StoreIO.toIO (Store.read address)) with - | .error error => pure (.error s!"{label}: wrapper decode failed: {error}") - | .ok wrapper => pure (.ok wrapper) - catch error => - pure (.error s!"{label}: store read failed: {error}") - -structure BenchSlot where - slot : AggregateSlot - proveSeconds : Float - -structure BaseProofBench where - wrapper : Ixon.Proof - proveSeconds : Float - -/-- Generate one ordinary shard proof through the same native EnvHandle path as -`ix prove --ixe E --ixes M --shard K`, but retain it in memory for the lift. -/ -def runBaseProof (label : String) (envHandle : Aiur.EnvHandle) - (owned : Array Address) (expectedClaim : Ix.Claim) - (ixvmSystem : Aiur.AiurSystem) (verifyIdx : Aiur.Bytecode.FunIdx) - (record : String → Json → IO Unit) : IO (Except String BaseProofBench) := do - let ownedBlob := owned.foldl (fun bytes address => bytes ++ address.hash) - ByteArray.empty - IO.println s!"[pair-bench] proving {label}" - (← IO.getStdout).flush - TracingTexray.resetPeakTreeRss - let (proved, proveSeconds) ← timed fun _ => - ixvmSystem.shardProveWithEnv verifyIdx envHandle ownedBlob - let provePeak ← TracingTexray.peakTreeRssBytes - let (claimBytes, proof) ← match proved with - | .error error => - record s!"{label}-prove" (errorJson error) - return .error s!"{label}: shardProveWithEnv failed: {error}" - | .ok (claimBytes, proof, _) => pure (claimBytes, proof) - let claim ← match Ixon.runGet Ix.Claim.get claimBytes with - | .error error => - record s!"{label}-prove" (errorJson s!"claim decode failed: {error}") - return .error s!"{label}: claim decode failed: {error}" - | .ok claim => pure claim - if claim != expectedClaim then - let error := "native shard prover returned a different CheckEnv claim" - record s!"{label}-prove" (errorJson error) - return .error s!"{label}: {error}" - let proofBytes := proof.toBytes - record s!"{label}-prove" (stageJson - [("seconds", jsonRound 6 proveSeconds), - ("peak-rss-bytes", Lean.toJson provePeak), - ("proof-bytes", Lean.toJson proofBytes.size), - ("source", Json.str "generated")]) - pure (.ok { - wrapper := { claim, proof := proofBytes } - proveSeconds - }) - -def reuseBaseProof (label address : String) (expectedClaim : Ix.Claim) - (record : String → Json → IO Unit) : IO (Except String BaseProofBench) := do - let wrapper ← match ← loadProofWrapper label address with - | .error error => return .error error - | .ok wrapper => pure wrapper - if wrapper.claim != expectedClaim then - return .error s!"{label}: persisted wrapper claim does not match the selected shard" - record s!"{label}-prove" (stageJson - [("seconds", jsonRound 6 0), - ("peak-rss-bytes", Lean.toJson (0 : Nat)), - ("proof-bytes", Lean.toJson wrapper.proof.size), - ("source", Json.str "reused")]) - pure (.ok { wrapper, proveSeconds := 0 }) - -def runLift (label : String) (prepared : PreparedShard) (wrapper : Ixon.Proof) - (spec : AggregateSlotSpec) (ixvmSystem recursionSystem : Aiur.AiurSystem) - (verifyIdx liftIdx : Aiur.Bytecode.FunIdx) (ixvmVk : ByteArray) - (record : String → Json → IO Unit) : - IO (Except String BenchSlot) := do - if wrapper.claim != prepared.claim then - return .error s!"{label}: bundled CheckEnv claim does not match the selected shard" - let innerProof ← match Aiur.Proof.ofBytesChecked wrapper.proof with - | .error error => return .error s!"{label}: inner proof decode failed: {error}" - | .ok proof => pure proof - let claimBytes := Ix.Claim.ser prepared.claim - let verifyInput := IxVM.ClaimHarness.packedDigestKey (Address.blake3 claimBytes) - let innerClaim := Aiur.buildClaim verifyIdx verifyInput #[] - - TracingTexray.resetPeakTreeRss - let (innerVerified, innerVerifySeconds) ← timed fun _ => - ixvmSystem.verify innerClaim innerProof - let innerVerifyPeak ← TracingTexray.peakTreeRssBytes - match innerVerified with - | .error error => - record s!"{label}-inner-verify" (errorJson error) - return .error s!"{label}: inner proof verification failed: {error}" - | .ok () => - record s!"{label}-inner-verify" (stageJson - [("seconds", jsonRound 6 innerVerifySeconds), - ("peak-rss-bytes", Lean.toJson innerVerifyPeak), - ("proof-bytes", Lean.toJson wrapper.proof.size)]) - - let innerProofAdvice ← match ixvmSystem.proofToAdviceBytes innerClaim innerProof with - | .error error => - return .error s!"{label}: inner proof advice encoding failed: {error}" - | .ok bytes => pure bytes - - let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] - let pubInput := MultiStark.verifierPubInput ixvmVk innerClaimsBytes - IO.println s!"[pair-bench] proving {label}" - (← IO.getStdout).flush - TracingTexray.resetPeakTreeRss - let ((outerClaim, proof), proveSeconds) ← timed fun _ => - recursionSystem.proveMultiStark liftIdx pubInput innerProofAdvice ixvmVk innerClaimsBytes - let provePeak ← TracingTexray.peakTreeRssBytes - if outerClaim != spec.outerClaim then - let error := "produced an unexpected outer claim" - record s!"{label}-prove" (errorJson error) - return .error s!"{label}: {error}" - let proofBytes := proof.toBytes - record s!"{label}-prove" (stageJson - [("seconds", jsonRound 6 proveSeconds), - ("peak-rss-bytes", Lean.toJson provePeak), - ("proof-bytes", Lean.toJson proofBytes.size)]) - - TracingTexray.resetPeakTreeRss - let (verified, verifySeconds) ← timed fun _ => - recursionSystem.verify outerClaim proof - let verifyPeak ← TracingTexray.peakTreeRssBytes - match verified with - | .error error => - record s!"{label}-outer-verify" (errorJson error) - return .error s!"{label}: lift proof verification failed: {error}" - | .ok () => - record s!"{label}-outer-verify" (stageJson - [("seconds", jsonRound 6 verifySeconds), - ("peak-rss-bytes", Lean.toJson verifyPeak)]) - - pure (.ok { - slot := { - statement := spec.statement - subjectCount := spec.subjectCount - outerClaim - proof - proofAddress? := none - openPreimages := #[innerClaimsBytes, claimBytes] - } - proveSeconds - }) - -def runJoin (item : ScheduledFold) (left right : AggregateSlot) - (spec : AggregateSlotSpec) (recursionSystem : Aiur.AiurSystem) - (joinIdx structuralJoinIdx : Aiur.Bytecode.FunIdx) - (recursionVk allowed : ByteArray) - (record : String → Json → IO Unit) : IO (Except String BenchSlot) := do - let output := spec.statement - let outputClaimBytes := Ix.Claim.ser output.claim - let pubInput := MultiStark.joinPubInput allowed outputClaimBytes - let leftClaimsBytes := MultiStark.serializeClaims #[left.outerClaim] - let rightClaimsBytes := MultiStark.serializeClaims #[right.outerClaim] - let preimagesBlob := MultiStark.joinPreimagesBlob - (left.openPreimages ++ right.openPreimages) - let trees := if item.structural then - MultiStark.CheckEnvTrees.structuralAdviceTrees left.statement right.statement output - else - MultiStark.CheckEnvTrees.adviceTrees left.statement right.statement output - let treesBlob := MultiStark.joinTreesBlob trees - let pathsBlob := if item.structural then - MultiStark.joinPathsBlob - (MultiStark.CheckEnvTrees.structuralPathAdvice left.statement right.statement output) - else MultiStark.joinPathsBlob #[] - let joinFunIdx := if item.structural then structuralJoinIdx else joinIdx - let label := if item.structural then "structural-join" else "flat-join" - let leftProofAdvice ← match recursionSystem.proofToAdviceBytes - left.outerClaim left.proof with - | .error error => - return .error s!"{label}: left child proof advice encoding failed: {error}" - | .ok bytes => pure bytes - let rightProofAdvice ← match recursionSystem.proofToAdviceBytes - right.outerClaim right.proof with - | .error error => - return .error s!"{label}: right child proof advice encoding failed: {error}" - | .ok bytes => pure bytes - - IO.println s!"[pair-bench] proving {label}" - (← IO.getStdout).flush - TracingTexray.resetPeakTreeRss - let (proved, proveSeconds) ← timed fun _ => - recursionSystem.proveMultiStarkJoin joinFunIdx pubInput - leftProofAdvice rightProofAdvice recursionVk - leftClaimsBytes rightClaimsBytes outputClaimBytes allowed - preimagesBlob treesBlob pathsBlob - let provePeak ← TracingTexray.peakTreeRssBytes - let (outerClaim, proof) ← match proved with - | .error error => - record s!"{label}-prove" (errorJson error) - return .error s!"{label}: prove failed: {error}" - | .ok result => pure result - if outerClaim != spec.outerClaim then - let error := "produced an unexpected outer claim" - record s!"{label}-prove" (errorJson error) - return .error s!"{label}: {error}" - let proofBytes := proof.toBytes - record s!"{label}-prove" (stageJson - [("seconds", jsonRound 6 proveSeconds), - ("peak-rss-bytes", Lean.toJson provePeak), - ("proof-bytes", Lean.toJson proofBytes.size)]) - - TracingTexray.resetPeakTreeRss - let (verified, verifySeconds) ← timed fun _ => - recursionSystem.verify outerClaim proof - let verifyPeak ← TracingTexray.peakTreeRssBytes - match verified with - | .error error => - record s!"{label}-verify" (errorJson error) - return .error s!"{label}: proof verification failed: {error}" - | .ok () => - record s!"{label}-verify" (stageJson - [("seconds", jsonRound 6 verifySeconds), - ("peak-rss-bytes", Lean.toJson verifyPeak)]) - - pure (.ok { - slot := { - statement := output - subjectCount := spec.subjectCount - outerClaim - proof - proofAddress? := none - openPreimages := #[outputClaimBytes] - } - proveSeconds - }) - -structure PairSelection where - leftBlocks : Array Address - rightBlocks : Array Address - leftId : Nat - rightId : Nat - leftLabel : String - rightLabel : String - expectedLeftSubjects? : Option Nat := none - expectedRightSubjects? : Option Nat := none - source : String - manifestPath? : Option String := none - -def usage : String := - "usage: bench-aggregate-pair [--ixe E] [--name-a A --name-b B] " ++ - "[--ixes M --shard-a A --shard-b B] " ++ - "[--proof-a ADDR --proof-b ADDR] " ++ - "[--queries N] [--structural-above N] [--json PATH] " ++ - "[--plan-only] [--texray]" - -def main (args : List String) : IO UInt32 := do - let ixePath := (argStr args "--ixe").getD "init.ixe" - let manifestPath? := argStr args "--ixes" - let requestedA? := argNat? args "--shard-a" - let requestedB? := argNat? args "--shard-b" - if requestedA?.isSome != requestedB?.isSome then - IO.eprintln "error: --shard-a and --shard-b must be supplied together" - IO.eprintln usage - return 2 - if let some requestedA := requestedA? then - if requestedB? == some requestedA then - IO.eprintln "error: --shard-a and --shard-b must differ" - return 2 - if manifestPath?.isNone && requestedA?.isSome then - IO.eprintln "error: --shard-a/--shard-b require --ixes" - return 2 - if manifestPath?.isSome && - ((argStr args "--name-a").isSome || (argStr args "--name-b").isSome) then - IO.eprintln "error: --name-a/--name-b select micro-shards and cannot accompany --ixes" - return 2 - let proofAHex? := argStr args "--proof-a" - let proofBHex? := argStr args "--proof-b" - if proofAHex?.isSome != proofBHex?.isSome then - IO.eprintln "error: --proof-a and --proof-b must be supplied together" - IO.eprintln usage - return 2 - let structuralAbove := (argNat? args "--structural-above").getD defaultStructuralAbove - let queries := (argNat? args "--queries").getD 50 - if queries == 0 then - IO.eprintln "error: --queries must be positive" - return 2 - let jsonPath? := argStr args "--json" - - TracingTexray.startSampler 25 - if hasFlag args "--texray" then TracingTexray.init {} - - let env ← match Ixon.deEnvAnon (← IO.FS.readBinFile ixePath) with - | .error error => IO.eprintln s!"deserialize {ixePath} failed: {error}"; return 1 - | .ok env => pure env - let selection : PairSelection ← match manifestPath? with - | none => - let nameA := (argStr args "--name-a").getD "False" - let nameB := (argStr args "--name-b").getD "True" - let leftBlocks ← match namedMicroShard env nameA with - | .error error => IO.eprintln error; return 1 - | .ok blocks => pure blocks - let rightBlocks ← match namedMicroShard env nameB with - | .error error => IO.eprintln error; return 1 - | .ok blocks => pure blocks - if leftBlocks == rightBlocks then - IO.eprintln s!"micro-shard names {nameA} and {nameB} resolve to the same block" - return 1 - pure { - leftBlocks, rightBlocks, leftId := 0, rightId := 1 - leftLabel := nameA, rightLabel := nameB - source := "init-named-microshards" - } - | some manifestPath => - let rawView ← match Ix.Cli.CheckCmd.parseIxesManifest - (← IO.FS.readBinFile manifestPath) 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, shardCounts) ← match rawView.pruneEmpty env with - | .error error => IO.eprintln error; return 1 - | .ok result => pure result - let (leftDense, rightDense) ← match requestedA?, requestedB? with - | none, none => match smallestSiblingPair? view.aggregationTree shardCounts with - | some pair => pure pair - | none => - IO.eprintln "manifest has no direct sibling leaf pair" - return 1 - | some requestedA, some requestedB => - let some denseA := view.shardIds.findIdx? (· == requestedA) - | IO.eprintln s!"manifest has no retained shard {requestedA}"; return 1 - let some denseB := view.shardIds.findIdx? (· == requestedB) - | IO.eprintln s!"manifest has no retained shard {requestedB}"; return 1 - pure (denseA, denseB) - | _, _ => - IO.eprintln "internal: partial shard override passed validation" - return 1 - let leftOriginal := view.shardIds[leftDense]! - let rightOriginal := view.shardIds[rightDense]! - pure { - leftBlocks := view.shards[leftDense]! - rightBlocks := view.shards[rightDense]! - leftId := leftOriginal - rightId := rightOriginal - leftLabel := s!"shard {leftOriginal}" - rightLabel := s!"shard {rightOriginal}" - expectedLeftSubjects? := some shardCounts[leftDense]! - expectedRightSubjects? := some shardCounts[rightDense]! - source := if requestedA?.isSome then "explicit-manifest-pair" - else "smallest-manifest-siblings" - manifestPath? := some manifestPath - } - let leftProofHex? := proofAHex? - let rightProofHex? := proofBHex? - let leftBlocks := selection.leftBlocks - let rightBlocks := selection.rightBlocks - let leftPrepared ← match prepareShard env leftBlocks with - | .error error => IO.eprintln s!"prepare {selection.leftLabel}: {error}"; return 1 - | .ok prepared => pure prepared - let rightPrepared ← match prepareShard env rightBlocks with - | .error error => IO.eprintln s!"prepare {selection.rightLabel}: {error}"; return 1 - | .ok prepared => pure prepared - if selection.expectedLeftSubjects?.any - (· != leftPrepared.statement.subjectCount) || - selection.expectedRightSubjects?.any - (· != rightPrepared.statement.subjectCount) then - IO.eprintln "internal: reconstructed subject counts differ from the manifest view" - return 1 - - let compactOps : Array FoldOp := #[.leaf 0, .leaf 1, .join 0 1] - let plan ← match schedulePlan compactOps - #[leftPrepared.statement.subjectCount, rightPrepared.statement.subjectCount] - structuralAbove with - | .error error => IO.eprintln error; return 1 - | .ok plan => pure plan - let some joinItem := plan[2]? - | IO.eprintln "internal: compact pair plan has no join slot"; return 1 - let mode := if joinItem.structural then "structural" else "flat" - let baseProofSource := if proofAHex?.isSome then "reused" else "generated" - IO.println (s!"[pair-bench] {selection.leftLabel}, {selection.rightLabel}: " ++ - s!"{leftPrepared.statement.subjectCount} + {rightPrepared.statement.subjectCount} " ++ - s!"subjects; {mode} join (threshold > {structuralAbove}); " ++ - s!"{baseProofSource} base proofs") - if hasFlag args "--plan-only" then return 0 - - let metadata : List (String × Json) := - [("schema-version", Lean.toJson (2 : Nat)), - ("ixe", Json.str ixePath), - ("ixes", selection.manifestPath?.map Json.str |>.getD Json.null), - ("left-shard", Lean.toJson selection.leftId), - ("right-shard", Lean.toJson selection.rightId), - ("left-label", Json.str selection.leftLabel), - ("right-label", Json.str selection.rightLabel), - ("left-subjects", Lean.toJson leftPrepared.statement.subjectCount), - ("right-subjects", Lean.toJson rightPrepared.statement.subjectCount), - ("pair-source", Json.str selection.source), - ("base-proof-source", Json.str baseProofSource), - ("queries", Lean.toJson queries), - ("join-mode", Json.str mode), - ("structural-above", Lean.toJson structuralAbove)] - let stagesRef ← IO.mkRef (#[] : Array (String × Json)) - let record (name : String) (row : Json) : IO Unit := do - let stages := (← stagesRef.get).push (name, row) - stagesRef.set stages - writeReport jsonPath? metadata "running" stages - IO.println s!"[pair-bench] recorded {name}" - writeReport jsonPath? metadata "running" #[] - - IO.println "[pair-bench] compiling IxVM and MultiStark systems" - let ixvmCompiled ← match ← compileToplevel "IxVM" IxVM.ixVM with - | .error error => IO.eprintln error; return 1 - | .ok compiled => pure compiled - let recursionCompiled ← match ← compileToplevel "MultiStark recursion" - MultiStark.multiStark with - | .error error => IO.eprintln error; return 1 - | .ok compiled => pure compiled - let verifyIdx := ixvmCompiled.getFuncIdx `verify_claim |>.get! - let liftIdx := recursionCompiled.getFuncIdx `verify_multi_stark_proof |>.get! - let joinIdx := recursionCompiled.getFuncIdx `join_two |>.get! - let structuralJoinIdx := recursionCompiled.getFuncIdx `join_two_structural |>.get! - let friParameters := benchmarkFriParameters queries - let recursionParameters : MultiStark.RecursionParameters := { - commitment := Aiur.defaultCommitmentParameters - fri := friParameters - } - let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode - Aiur.defaultCommitmentParameters friParameters - let recursionSystem := MultiStark.buildRecursionSystem recursionCompiled.bytecode - recursionParameters - let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with - | .error error => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {error}"; return 1 - | .ok handle => pure handle - let ixvmVk := ixvmSystem.vkBytes - let recursionVk := recursionSystem.vkBytes - let allowed := MultiStark.allowedBlob ixvmVk verifyIdx recursionVk liftIdx - joinIdx structuralJoinIdx - let specs ← match buildAggregateSlotSpecs plan #[leftPrepared, rightPrepared] - ixvmVk recursionVk allowed verifyIdx liftIdx joinIdx structuralJoinIdx - recursionParameters with - | .error error => IO.eprintln s!"prepare pair slots: {error}"; return 1 - | .ok specs => pure specs - let some leftSpec := specs[0]? - | IO.eprintln "internal: pair specs have no left lift"; return 1 - let some rightSpec := specs[1]? - | IO.eprintln "internal: pair specs have no right lift"; return 1 - let some rootSpec := specs[2]? - | IO.eprintln "internal: pair specs have no join"; return 1 - - let leftBase ← match leftProofHex? with - | some proofHex => - match ← reuseBaseProof "base-left" proofHex leftPrepared.claim record with - | .error error => - IO.eprintln error - writeReport jsonPath? metadata "error" (← stagesRef.get) - return 1 - | .ok result => pure result - | none => - let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks env leftBlocks - match ← runBaseProof "base-left" envHandle owned leftPrepared.claim - ixvmSystem verifyIdx record with - | .error error => - IO.eprintln error - writeReport jsonPath? metadata "error" (← stagesRef.get) - return 1 - | .ok result => pure result - let rightBase ← match rightProofHex? with - | some proofHex => - match ← reuseBaseProof "base-right" proofHex rightPrepared.claim record with - | .error error => - IO.eprintln error - writeReport jsonPath? metadata "error" (← stagesRef.get) - return 1 - | .ok result => pure result - | none => - let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks env rightBlocks - match ← runBaseProof "base-right" envHandle owned rightPrepared.claim - ixvmSystem verifyIdx record with - | .error error => - IO.eprintln error - writeReport jsonPath? metadata "error" (← stagesRef.get) - return 1 - | .ok result => pure result - - let left ← match ← runLift "lift-left" leftPrepared leftBase.wrapper leftSpec - ixvmSystem recursionSystem verifyIdx liftIdx ixvmVk record with - | .error error => - IO.eprintln error - writeReport jsonPath? metadata "error" (← stagesRef.get) - return 1 - | .ok slot => pure slot - let right ← match ← runLift "lift-right" rightPrepared rightBase.wrapper rightSpec - ixvmSystem recursionSystem verifyIdx liftIdx ixvmVk record with - | .error error => - IO.eprintln error - writeReport jsonPath? metadata "error" (← stagesRef.get) - return 1 - | .ok slot => pure slot - let root ← match ← runJoin joinItem left.slot right.slot rootSpec - recursionSystem joinIdx structuralJoinIdx recursionVk allowed record with - | .error error => - IO.eprintln error - writeReport jsonPath? metadata "error" (← stagesRef.get) - return 1 - | .ok slot => pure slot - - let expectedStatement := if joinItem.structural then - leftPrepared.statement.joinStructural rightPrepared.statement - else leftPrepared.statement.join rightPrepared.statement - if root.slot.statement.claim != expectedStatement.claim then - IO.eprintln "pair root statement differs from independent host reconstruction" - writeReport jsonPath? metadata "error" (← stagesRef.get) - return 1 - - -- Cheap negative control: the valid proof must reject under a one-word - -- mutation of its exact outer claim. - let some outerWord := root.slot.outerClaim[2]? - | IO.eprintln "internal: aggregate outer claim is shorter than three words"; return 1 - let wrongOuter := root.slot.outerClaim.set! 2 (outerWord + 1) - let (wrongResult, negativeSeconds) ← timed fun _ => - recursionSystem.verify wrongOuter root.slot.proof - match wrongResult with - | .ok () => - record "negative-control" (errorJson "proof accepted a mutated outer claim") - writeReport jsonPath? metadata "error" (← stagesRef.get) - return 1 - | .error _ => - record "negative-control" (stageJson [("seconds", jsonRound 6 negativeSeconds)]) - - let baseProveSeconds := leftBase.proveSeconds + rightBase.proveSeconds - let recursiveProveSeconds := left.proveSeconds + right.proveSeconds + root.proveSeconds - let serialProveSeconds := baseProveSeconds + recursiveProveSeconds - let parallelLowerBound := - max (leftBase.proveSeconds + left.proveSeconds) - (rightBase.proveSeconds + right.proveSeconds) + root.proveSeconds - let rootBytes := root.slot.proof.toBytes - let summary := stageJson - [("base-prove-seconds", jsonRound 6 baseProveSeconds), - ("recursive-prove-seconds", jsonRound 6 recursiveProveSeconds), - ("serial-total-prove-seconds", jsonRound 6 serialProveSeconds), - ("parallel-branch-lower-bound-seconds", jsonRound 6 parallelLowerBound), - ("root-proof-bytes", Lean.toJson rootBytes.size), - ("root-proof-digest", Json.str (toString (Address.blake3 rootBytes))), - ("subjects", Lean.toJson root.slot.subjectCount), - ("retains-assumptions", Lean.toJson root.slot.statement.assumptions.isSome)] - record "summary" summary - writeReport jsonPath? metadata "ok" (← stagesRef.get) - IO.println (s!"[pair-bench] OK: serial base proving {baseProveSeconds}s; " ++ - s!"recursive proving {recursiveProveSeconds}s; total {serialProveSeconds}s; " ++ - s!"parallel branch lower bound {parallelLowerBound}s; root {rootBytes.size} bytes") - pure 0 - -end Benchmarks.AggregatePair - -def main (args : List String) : IO UInt32 := - Benchmarks.AggregatePair.main args 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/Typecheck.lean b/Benchmarks/Typecheck.lean index a1760dfbd..6cf8abb33 100644 --- a/Benchmarks/Typecheck.lean +++ b/Benchmarks/Typecheck.lean @@ -6,6 +6,7 @@ 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 @@ -74,8 +75,8 @@ lake exe bench-typecheck --ixe --consts [--consts-file

] [ `phase-stark-*` fields cover the pair. Conflicts with --execute-only. --join with --recursive and exactly two constants, benchmark the - aggregate-first flat join after both singleton-CheckEnv - proofs have been lifted. Emits one `left + right` JSON row + 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 @@ -103,10 +104,10 @@ four phases: 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, lift both resulting - proofs, then execute/prove/verify `join_two`. The pair gets a dedicated JSON - row because the join is one shared operation, not a cost attributable to - either child independently. + 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 @@ -224,11 +225,11 @@ structure Result where recursiveVerifySec : Option Float := none deriving Inhabited -/-- The successfully verified lift artifact retained for the optional binary +/-- 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 join opens below it. -/ -structure LiftArtifact where + preimage that the converged join opens below it. -/ +structure JoinArtifact where label : String constants : Nat statement : MultiStark.CheckEnvTrees @@ -237,7 +238,7 @@ structure LiftArtifact where outerClaim : Array Aiur.G proof : Aiur.Proof -/-- Measurements for the one pair-wide `join_two` operation. Kept separate +/-- 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. -/ @@ -484,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 @@ -623,7 +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 lifted : Array LiftArtifact := #[] + let mut joinArtifacts : Array JoinArtifact := #[] for i in [:ordered.size] do let (r, addr) := ordered[i]! if r.failed then continue @@ -773,14 +788,14 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do {r.name} differs from host reconstruction" let statement ← IO.ofExcept <| MultiStark.CheckEnvTrees.ofClaim expectedClaim trees - lifted := lifted.push { + joinArtifacts := joinArtifacts.push { label := r.name constants := r.constants statement innerClaimsBytes checkEnvClaimBytes - outerClaim := rvClaim - proof := rvProof + outerClaim := claim + proof := proof } | .error _, _ => pure () | .ok (), none => @@ -789,74 +804,72 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do catch e => IO.eprintln s!" prove {r.name} threw: {e}" - -- Phase 4 (--recursive --join): one pair-wide flat aggregate join. The two - -- child rows remain ordinary IxVM/lift measurements; the shared join lands - -- under its own stable `left + right` row so it is neither duplicated nor - -- assigned arbitrarily to one child. + -- 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: flat join ──" + 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 := lifted.find? fun artifact => artifact.label == leftLabel | do - IO.eprintln s!"join benchmark: no verified lift for {leftLabel}" + 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 := lifted.find? fun artifact => artifact.label == rightLabel | do - IO.eprintln s!"join benchmark: no verified lift for {rightLabel}" + 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 (vCompiled, liftIdx, vSystem) := vCtx | do - IO.eprintln "join benchmark: recursion context was not built" - return 1 - let some joinIdx := vCompiled.getFuncIdx `join_two | do - IO.eprintln "join benchmark: join_two entrypoint missing" - return 1 - let some structuralJoinIdx := vCompiled.getFuncIdx `join_two_structural | do - IO.eprintln "join benchmark: join_two_structural entrypoint missing" + let some (aggrCompiled, aggrIdx, aggrSystem) := aggrCtx | do + IO.eprintln "join benchmark: ix_aggr context was not built" return 1 let ixvmVk := aiurSystem.vkBytes - let recursionVk := vSystem.vkBytes - let allowed := MultiStark.allowedBlob ixvmVk funIdx recursionVk liftIdx - joinIdx structuralJoinIdx - let outputStatement := left.statement.join right.statement + 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 := MultiStark.joinPubInput allowed outputClaimBytes - let leftOuterBytes := MultiStark.serializeClaims #[left.outerClaim] - let rightOuterBytes := MultiStark.serializeClaims #[right.outerClaim] - let preimagesBlob := MultiStark.joinPreimagesBlob - #[left.innerClaimsBytes, right.innerClaimsBytes, - left.checkEnvClaimBytes, right.checkEnvClaimBytes] - let treesBlob := MultiStark.joinTreesBlob <| - MultiStark.CheckEnvTrees.adviceTrees - left.statement right.statement outputStatement - let pathsBlob := MultiStark.joinPathsBlob #[] - let leftProofAdvice ← match vSystem.proofToAdviceBytes + 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 vSystem.proofToAdviceBytes + 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 _ => - vCompiled.bytecode.executeMultiStarkJoin joinIdx pubInput - leftProofAdvice rightProofAdvice recursionVk - leftOuterBytes rightOuterBytes outputClaimBytes allowed + 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!" ❌ join verifier REJECTED {pairName}: {e}" + IO.eprintln s!" ❌ ix_aggr direct join REJECTED {pairName}: {e}" writeRejectedJoin pairName joinRejected := true pure none | .ok (_, queryCounts) => - let stats := Aiur.computeStats vCompiled queryCounts vSystem.circuitShapes + let stats := Aiur.computeStats aggrCompiled queryCounts aggrSystem.circuitShapes (logBlowup := commitParams.logBlowup) IO.println s!" {pairName}: join-execute={joinExecuteSec}s \ join-fft-cost={stats.totalFftCost}" @@ -867,23 +880,23 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do (← IO.getStdout).flush TracingTexray.resetPeakTreeRss let (joinProveResult, joinProveSec) ← timed fun _ => - vSystem.proveMultiStarkJoin joinIdx pubInput - leftProofAdvice rightProofAdvice recursionVk - leftOuterBytes rightOuterBytes outputClaimBytes allowed + 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 joinIdx pubInput #[] + 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 _ => - vSystem.verify joinClaim joinProof + aggrSystem.verify joinClaim joinProof let joinVerifySec? ← match joinVerifyResult with | .ok () => pure (some joinVerifySec) | .error e => diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index 80e2b0f87..85e0076ce 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -45,9 +45,6 @@ structure AggregateSlot where proofAddress? : Option Address /-- Serialized singleton outer-claim list consumed by a parent. -/ claimsBytes : ByteArray := ByteArray.empty - /-- Legacy benchmark preimage closure retained through M1-f. The converged - parent only needs the direct `CheckEnv` preimage for each child. -/ - openPreimages : Array ByteArray /-- Everything claim-derived about a slot, computed for the whole fold before the first cache lookup or proof. -/ @@ -365,68 +362,7 @@ def schedulePlan (plan : Array Ix.Cli.CheckCmd.AggregationTree.FoldOp) } pure scheduled -/-- Derive every slot statement, outer claim, and cache key before proving. -This makes resume independent of execution order and lets manifest changes -invalidate only the claim-changed subtree. -/ -def buildAggregateSlotSpecs (plan : Array ScheduledFold) - (prepared : Array PreparedShard) (ixvmVk recursionVk allowed : ByteArray) - (verifyIdx liftIdx joinIdx structuralJoinIdx : 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 innerClaimsBytes := MultiStark.serializeClaims #[innerClaim] - let pubInput := MultiStark.verifierPubInput ixvmVk innerClaimsBytes - let outerClaim := Aiur.buildClaim liftIdx pubInput #[] - specs := specs.push { - statement := preparedShard.statement - subjectCount := item.subjectCount - outerClaim - cacheKey := aggregateCacheKey recursionVk 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 output := if item.structural then - left.statement.joinStructural right.statement - else - left.statement.join right.statement - if output.subjectCount != item.subjectCount then - throw s!"aggregate join reconstructs {output.subjectCount} subjects, \ - but the schedule records {item.subjectCount}" - let outputClaimBytes := Ix.Claim.ser output.claim - let pubInput := MultiStark.joinPubInput allowed outputClaimBytes - let joinFunIdx := if item.structural then structuralJoinIdx else joinIdx - let outerClaim := Aiur.buildClaim joinFunIdx pubInput #[] - specs := specs.push { - statement := output - subjectCount := item.subjectCount - outerClaim - cacheKey := aggregateCacheKey recursionVk recursionParameters outerClaim - } - pure specs - -/-! ## Converged single-entrypoint slot derivation - -The legacy helper above remains temporarily available to the M1-e/M1-f test -and benchmark union. Production uses the helpers below exclusively. -/ +/-! ## 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. -/ @@ -793,7 +729,6 @@ private def proveAggregateSlot (ctx : AggregateProveContext) (slotIdx : Nat) proof := innerProof proofAddress? := none claimsBytes := innerClaimsBytes - openPreimages := #[claimBytes] } | .aggr => let cached? ← match ctx.cacheDir? with @@ -832,7 +767,6 @@ private def proveAggregateSlot (ctx : AggregateProveContext) (slotIdx : Nat) proof proofAddress? claimsBytes := MultiStark.serializeClaims #[spec.outerClaim] - openPreimages := #[claimBytes] } | .join leftIdx rightIdx => let some left := (slots[leftIdx]?).join @@ -908,7 +842,6 @@ private def proveAggregateSlot (ctx : AggregateProveContext) (slotIdx : Nat) proof proofAddress? claimsBytes := MultiStark.serializeClaims #[spec.outerClaim] - openPreimages := #[outputClaimBytes] } /-- Aggregate with an explicit recursion-proof configuration. The CLI wrapper diff --git a/Tests/Aggr.lean b/Tests/Aggr.lean index 1c5c9c34c..e17ab23a1 100644 --- a/Tests/Aggr.lean +++ b/Tests/Aggr.lean @@ -154,6 +154,18 @@ def smokeSuite : IO UInt32 := do 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] && @@ -167,6 +179,19 @@ def smokeSuite : IO UInt32 := do 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 == #[ @@ -499,6 +524,9 @@ def smokeSuite : IO UInt32 := do 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" diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index 81e8a2ad6..ebea33c90 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -508,41 +508,31 @@ def joinSmokeSuite : IO UInt32 := do { op := .leaf 1, subjectCount := 1, structural := false }, { op := .join 0 1, subjectCount := 3, structural := false } ] - let cachePrepared : Array Ix.Cli.AggregateCmd.PreparedShard := #[ - { claim := leftStatement.claim, statement := leftStatement }, - { claim := rightStatement.claim, statement := rightStatement } + -- 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 cacheSpecs := Ix.Cli.AggregateCmd.buildAggregateSlotSpecs cachePlan - cachePrepared fakeIxvmVk recursionVk allowed verifyIdx liftIdx childJoinIdx - childStructuralJoinIdx childRecursionParameters - let cacheSpecsComplete : Bool := match cacheSpecs with - | .ok specs => match specs[0]?, specs[1]?, specs[2]? with - | some left, some right, some root => - specs.size == 3 && left.outerClaim == leftOuter && - right.outerClaim == rightOuter && - root.statement.claim == outputStatement.claim && - root.outerClaim == Aiur.buildClaim childJoinIdx pubInput #[] && - left.cacheKey == liftCacheKey - | _, _, _ => false - | .error _ => false let cachedLiftBytes := Ixon.Proof.ser cachedLiftWrapper - let resumedLift? ← match cacheSpecs with - | .ok specs => - match specs[0]? with - | some spec => - Ix.Cli.AggregateCmd.loadCachedAggregateProofWith - (fun _ => pure cachedLiftBytes) cacheDir 0 spec childSystem - | none => pure none - | .error _ => pure none - let corruptStoreLift? ← match cacheSpecs with - | .ok specs => - match specs[0]? with - | some spec => - Ix.Cli.AggregateCmd.loadCachedAggregateProofWith - (fun _ => pure (cachedLiftBytes.push 0xff)) - cacheDir 0 spec childSystem - | none => pure none - | .error _ => pure none + 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 @@ -1045,8 +1035,6 @@ def joinSmokeSuite : IO UInt32 := do recursionParametersIndependent, test "aggregate cache key binds version, recursion vk, FRI params, and outer claim" cacheKeyInputsBound, - test "all aggregate slot claims and cache keys are prepared before proving" - cacheSpecsComplete, test "aggregate cache index atomically round-trips a store address" cacheIndexRoundTrip, test "aggregate cache treats a corrupt index as an invalid hint" diff --git a/lakefile.lean b/lakefile.lean index 0c244aa3a..18710c090 100644 --- a/lakefile.lean +++ b/lakefile.lean @@ -151,8 +151,8 @@ lean_exe «bench-recursion-debug» where root := `Benchmarks.RecursionDebug supportInterpreter := true -lean_exe «bench-aggregate-pair» where - root := `Benchmarks.AggregatePair +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 From f0909c70672b13677d2eb22ed48a09786ec522ce Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 1 Sep 2026 11:18:46 +0000 Subject: [PATCH 25/44] Update Aiur to Plonky3 0.6 Update the multi-stark dependency and Rust toolchain for Plonky3 0.6, along with the Rust 1.98 lint migrations required to keep the workspace warning-free. Refresh the Rust-compatible Blake3.lean pin in both root and compile-package manifests. Adapt recursive Aiur verification to Plonky3's pruned FRI multiproofs. Native proofs retain their compact serialized representation and native verification path; the FFI expands authenticated Merkle frontiers into per-query advice only when entering the existing recursive verifier circuit. Preserve the packed claim-digest convention in the recursion diagnostic and exercise the advice boundary in the end-to-end test and benchmark paths. CPU and CUDA recursive q1 runs produce identical 823,485-byte inner proofs and 331,273-byte outer proofs. The q50 Vector.extract_append workload retains identical CPU/CUDA proof sizes. Inner plus outer STARK proving measures 65.87s on CPU and 8.81s with CUDA on the RTX PRO 6000, a 7.48x speedup. --- Benchmarks/Compile/lake-manifest.json | 4 +- Benchmarks/RecursionDebug.lean | 14 +- Benchmarks/Typecheck.lean | 11 +- Cargo.lock | 214 ++++++++++-------- Cargo.toml | 3 +- Ix/Aiur/Protocol.lean | 6 + Tests/MultiStark.lean | 6 +- crates/aiur/src/execute.rs | 6 +- crates/aiur/src/gadgets/bytes1.rs | 15 +- crates/aiur/src/gadgets/bytes2.rs | 4 +- crates/aiur/src/synthesis.rs | 16 ++ crates/common/src/address.rs | 6 +- crates/compile/src/compile.rs | 2 +- crates/compile/src/compile/aux_gen/brecon.rs | 6 +- .../compile/src/compile/aux_gen/cases_on.rs | 2 +- crates/compile/src/compile/env.rs | 2 +- crates/compile/src/compile/mutual.rs | 24 +- crates/ffi/src/aiur/protocol.rs | 23 +- crates/ffi/src/catalog.rs | 10 +- crates/ffi/src/kernel.rs | 2 +- crates/ffi/src/lean_env.rs | 4 +- crates/ffi/src/lean_ixon/sharing.rs | 2 +- crates/ixon/src/diff.rs | 2 +- crates/ixvm-codegen/src/aiur_ixvm_witness.rs | 4 +- crates/kernel/src/def_eq.rs | 4 +- crates/kernel/src/inductive.rs | 11 +- crates/kernel/src/ingress.rs | 12 +- crates/kernel/src/perf.rs | 2 +- crates/kernel/src/tc.rs | 3 +- crates/kernel/src/whnf.rs | 6 +- flake.lock | 8 +- flake.nix | 4 +- lake-manifest.json | 4 +- lakefile.lean | 2 +- rust-toolchain.toml | 2 +- 35 files changed, 251 insertions(+), 195 deletions(-) diff --git a/Benchmarks/Compile/lake-manifest.json b/Benchmarks/Compile/lake-manifest.json index 5ffda5058..74b77d83a 100644 --- a/Benchmarks/Compile/lake-manifest.json +++ b/Benchmarks/Compile/lake-manifest.json @@ -182,10 +182,10 @@ "type": "git", "subDir": null, "scope": "", - "rev": "db25a8a21579d8211eec4347402721f5674bf2c1", + "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba", "name": "Blake3", "manifestFile": "lake-manifest.json", - "inputRev": "db25a8a21579d8211eec4347402721f5674bf2c1", + "inputRev": "e6e908bfd3af607ab44fb462fa2276a2c81addba", "inherited": true, "configFile": "lakefile.lean"}, {"url": "https://github.com/argumentcomputer/LSpec", diff --git a/Benchmarks/RecursionDebug.lean b/Benchmarks/RecursionDebug.lean index 41167de24..ec4a059b7 100644 --- a/Benchmarks/RecursionDebug.lean +++ b/Benchmarks/RecursionDebug.lean @@ -102,19 +102,21 @@ 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` takes the packed Blake3 digest used by the + -- production typecheck path: eight field elements of four bytes. 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]) + 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" diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean index 177905eae..359323bcf 100644 --- a/Benchmarks/Typecheck.lean +++ b/Benchmarks/Typecheck.lean @@ -592,10 +592,17 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do let claimBytes := MultiStark.serializeClaims #[claim] let vkBytes := aiurSystem.vkBytes let pubInput := MultiStark.verifierPubInput vkBytes claimBytes + -- Native proof bytes use P3's pruned multiproof format. The + -- in-circuit verifier consumes equivalent per-query path advice. + 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 + vCompiled.bytecode.executeMultiStark vIdx pubInput adviceBytes vkBytes claimBytes useInterp match rvRes with | .error e => @@ -621,7 +628,7 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do (← IO.getStdout).flush TracingTexray.resetPeakTreeRss let (rvProveRes, rvProveSec) ← timed fun _ => - vSystem.proveMultiStark vIdx pubInput proofBytes vkBytes + vSystem.proveMultiStark vIdx pubInput adviceBytes vkBytes claimBytes useInterp let (rvClaim, rvProof) ← match rvProveRes with | .ok result => pure result diff --git a/Cargo.lock b/Cargo.lock index db881f753..0141466ef 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", @@ -192,7 +192,7 @@ name = "bignat" version = "0.1.0" source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5" 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.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" +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", @@ -1907,7 +1927,7 @@ dependencies = [ "bignat", "bindgen", "cc", - "num-bigint", + "num-bigint 0.4.6", ] [[package]] @@ -2084,7 +2104,7 @@ dependencies = [ [[package]] name = "multi-stark" version = "0.1.0" -source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=e43201522a95775d1495b4467fbab69fbf7a1ae8#e43201522a95775d1495b4467fbab69fbf7a1ae8" +source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=33b4454aa63b88427b3d3cc09980fe86ddeb7e5f#33b4454aa63b88427b3d3cc09980fe86ddeb7e5f" dependencies = [ "bincode", "itertools 0.14.0", @@ -2096,7 +2116,6 @@ dependencies = [ "p3-field", "p3-fri", "p3-goldilocks", - "p3-interpolation", "p3-keccak", "p3-matrix", "p3-maybe-rayon", @@ -2371,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" @@ -2506,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=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" 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=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "blake3", "p3-symmetric", @@ -2526,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=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-field", "p3-maybe-rayon", - "p3-monty-31", "p3-symmetric", "p3-util", "tracing", @@ -2539,40 +2568,39 @@ 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=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", - "p3-challenger", + "itertools 0.15.0", "p3-dft", "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=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" 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=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", - "num-bigint", + "itertools 0.15.0", + "num-bigint 0.5.1", "p3-maybe-rayon", "p3-util", "paste", @@ -2583,32 +2611,31 @@ dependencies = [ [[package]] name = "p3-fri" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" 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=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "num-bigint", - "p3-challenger", + "num-bigint 0.5.1", "p3-dft", "p3-field", "p3-mds", @@ -2619,23 +2646,13 @@ dependencies = [ "paste", "rand 0.10.1", "serde", -] - -[[package]] -name = "p3-interpolation" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" -dependencies = [ - "p3-field", - "p3-matrix", - "p3-maybe-rayon", - "p3-util", + "spin 0.12.3", ] [[package]] name = "p3-keccak" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-symmetric", "p3-util", @@ -2644,10 +2661,10 @@ dependencies = [ [[package]] name = "p3-matrix" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", + "itertools 0.15.0", "p3-field", "p3-maybe-rayon", "p3-util", @@ -2658,16 +2675,16 @@ dependencies = [ [[package]] name = "p3-maybe-rayon" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" 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=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-dft", "p3-field", @@ -2678,10 +2695,10 @@ dependencies = [ [[package]] name = "p3-merkle-tree" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", + "itertools 0.15.0", "p3-commit", "p3-field", "p3-matrix", @@ -2690,47 +2707,41 @@ dependencies = [ "p3-util", "rand 0.10.1", "serde", + "spin 0.12.3", "thiserror", "tracing", ] [[package]] -name = "p3-monty-31" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +name = "p3-multilinear-util" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" 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=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" 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=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-field", "p3-mds", @@ -2739,12 +2750,24 @@ dependencies = [ "rand 0.10.1", ] +[[package]] +name = "p3-security" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +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=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ - "itertools 0.14.0", + "itertools 0.15.0", "p3-field", "p3-util", "serde", @@ -2752,11 +2775,11 @@ dependencies = [ [[package]] name = "p3-util" -version = "0.5.1" -source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64" +version = "0.6.0" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ + "p3-maybe-rayon", "serde", - "transpose", ] [[package]] @@ -3158,6 +3181,7 @@ version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" dependencies = [ + "chacha20", "getrandom 0.4.2", "rand_core 0.10.1", ] @@ -3614,6 +3638,12 @@ name = "spin" version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "023a211cb3138dbc438680b32560ad89f699977624c9f8dbb95a47d5b4c07dd3" + +[[package]] +name = "spin" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0134f9043ed38b087ac4f7d4af44c79e2c9e5094421fe3164f435ce585953b10" dependencies = [ "lock_api", ] @@ -3647,12 +3677,6 @@ dependencies = [ "windows-sys 0.61.2", ] -[[package]] -name = "strength_reduce" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82" - [[package]] name = "strsim" version = "0.11.1" @@ -4064,16 +4088,6 @@ dependencies = [ "tracing-subscriber", ] -[[package]] -name = "transpose" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e" -dependencies = [ - "num-integer", - "strength_reduce", -] - [[package]] name = "try-lock" version = "0.2.5" diff --git a/Cargo.toml b/Cargo.toml index 1791ae265..70d17d38e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -56,7 +56,7 @@ libc = "0.2" log = "0.4" memmap2 = "0.9" mimalloc = { version = "0.1", default-features = false } -multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "e43201522a95775d1495b4467fbab69fbf7a1ae8" } +multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "33b4454aa63b88427b3d3cc09980fe86ddeb7e5f" } 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/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 412ad59ea..43ce405ec 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -189,6 +189,12 @@ def shardProveWithEnv (system : @& AiurSystem) opaque verify : @& AiurSystem → @& Array G → @& Proof → Except String Unit +/-- Re-encode a natively valid proof into the per-query Merkle-path advice +transport consumed by the in-circuit recursive verifier. -/ +@[extern "rs_aiur_proof_to_advice_bytes"] +opaque proofToAdviceBytes : @& AiurSystem → + @& Array G → @& Proof → Except String ByteArray + end AiurSystem namespace Bytecode.Toplevel diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index 26d62327d..4e36fa670 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -157,7 +157,9 @@ def endToEndSuite : IO UInt32 := do | .ok result => pure result | .error e => IO.eprintln s!"factorial prove failed: {e}"; return 1 let expectedClaim := buildClaim facIdx input #[Aiur.G.ofNat 120] - let proofBytes := proof.toBytes + 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 @@ -201,7 +203,7 @@ 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) + 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 := diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index 3037a1d52..d5d847c95 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(|row| std::cmp::Reverse(row.2)); let total_entries: usize = rows.iter().map(|r| r.1).sum(); let total_elems: usize = rows.iter().map(|r| r.2).sum(); eprintln!( @@ -1053,7 +1053,9 @@ fn biguint_to_klimbs_u64(n: &num_bigint::BigUint) -> Vec { bytes.push(0); } bytes - .chunks_exact(8) + .as_chunks::<8>() + .0 + .iter() .map(|c| { let mut a = [0u8; 8]; a.copy_from_slice(c); diff --git a/crates/aiur/src/gadgets/bytes1.rs b/crates/aiur/src/gadgets/bytes1.rs index 667cb8ad9..e3acd1552 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> { 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::() + .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)) } @@ -168,7 +171,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::() + .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..e013a6a34 100644 --- a/crates/aiur/src/gadgets/bytes2.rs +++ b/crates/aiur/src/gadgets/bytes2.rs @@ -304,7 +304,9 @@ impl AiurGadget for Bytes2 { let xor_split4_channel = u8_xor_split4_channel(); rows - .chunks_exact_mut(TRACE_WIDTH) + .as_chunks_mut::() + .0 + .iter_mut() .enumerate() .zip(&record.bytes2_queries.0) .zip(row_writers.iter_mut()) diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 552743c28..70e598184 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -443,6 +443,22 @@ impl AiurSystem { ) -> Result<(), VerificationError> { self.system.verify(claim, proof) } + + /// Re-encode a verified proof into the per-query authentication-path + /// transport consumed by the in-circuit recursive verifier. + pub fn proof_to_advice_bytes( + &self, + claim: &[G], + proof: &AiurProof, + ) -> Result, multi_stark::advice::AdviceError> { + multi_stark::advice::proof_to_advice_bytes( + &self.system, + self.commitment_parameters, + self.fri_parameters, + &[claim], + proof, + ) + } } #[cfg(test)] diff --git a/crates/common/src/address.rs b/crates/common/src/address.rs index 334aafd13..0bc032456 100644 --- a/crates/common/src/address.rs +++ b/crates/common/src/address.rs @@ -46,10 +46,12 @@ impl Address { } /// Iterate addresses out of a flat `[u8; 32 * N]` byte blob. Trailing - /// bytes shorter than 32 are silently dropped (via `chunks_exact`). + /// bytes shorter than 32 are silently dropped. pub fn unpack(bytes: &[u8]) -> impl Iterator + '_ { 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 = Vec::new(); let mut ctor_args: Vec = 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 = 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 = Vec::new(); let mut wrapper_decls: Vec = 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 = 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 = 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 = 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 = 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 = 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 9adb0cd3c..167c8ace1 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -143,6 +143,21 @@ extern "C" fn rs_aiur_system_verify( } } +/// `AiurSystem.proofToAdviceBytes`: expand a valid pruned FRI multiproof into +/// the per-query advice transport consumed by the recursive verifier. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_proof_to_advice_bytes( + aiur_system_obj: LeanExternal>, + claim: LeanArray>, + proof_obj: LeanExternal>, +) -> LeanExcept { + 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 @@ -402,7 +417,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(), ) @@ -685,7 +702,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(), ); 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..87c09e57c 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(|entry| std::cmp::Reverse(entry.1.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(|entry| std::cmp::Reverse(entry.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..f49218f49 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(|entry| std::cmp::Reverse(entry.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..dd09492d3 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(|entry| std::cmp::Reverse(entry.0)); 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/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 { fn packed_digest_key(addr: &Address) -> Vec { addr .as_bytes() - .chunks_exact(4) + .as_chunks::<4>() + .0 + .iter() .map(|w| { G::from_u32( u32::from(w[0]) 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 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/tc.rs b/crates/kernel/src/tc.rs index 9cbf56742..1c98f71da 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) = &mut self.env.profile_sink { 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 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 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/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 546e2f6df..9254cf0bc 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 3f585ebb5..b6a2d07d5 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" 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" From eab18e4eebd8699972cce16c17f3b0c0d10fc14b Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 1 Sep 2026 12:02:00 +0000 Subject: [PATCH 26/44] Provision Rust for fresh benchmark base builds PR benchmark runs execute trusted workflow YAML from the default branch while loading composite actions from the PR checkout. When Bencher data and binary caches are unavailable, the workflow checks out main under base/ and asks Lake to rebuild it without first installing the Rust channel pinned by that checkout. Teach the existing CPU provenance action to install the base checkout's validated Rust channel and profile immediately before an uncached base build. The step is a no-op when the toolchain is already available and leaves cached benchmark comparisons unchanged. --- .github/actions/log-cpu/action.yml | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/.github/actions/log-cpu/action.yml b/.github/actions/log-cpu/action.yml index 69ae6dc05..b47cea486 100644 --- a/.github/actions/log-cpu/action.yml +++ b/.github/actions/log-cpu/action.yml @@ -30,6 +30,32 @@ inputs: runs: using: composite steps: + # PR benchmarks execute trusted workflow YAML from the default branch but + # load this action from the PR checkout. Ensure a freshly checked-out base + # has its pinned Rust toolchain before Lake invokes Cargo. + - name: Bootstrap base Rust toolchain + if: inputs.label == 'Base benchmark binary build CPU' + shell: bash + run: | + set -euo pipefail + + toolchain_file=base/rust-toolchain.toml + [ -f "$toolchain_file" ] || { echo "::error::$toolchain_file is missing"; exit 1; } + channel=$(awk -F '"' '/^[[:space:]]*channel[[:space:]]*=/ { print $2; exit }' "$toolchain_file") + profile=$(awk -F '"' '/^[[:space:]]*profile[[:space:]]*=/ { print $2; exit }' "$toolchain_file") + if [[ ! "$channel" =~ ^[A-Za-z0-9._+-]+$ ]]; then + echo "::error::$toolchain_file has an invalid Rust channel" + exit 1 + fi + case "${profile:-default}" in + minimal|default|complete) ;; + *) echo "::error::$toolchain_file has an invalid Rust profile"; exit 1 ;; + esac + + rustup run "$channel" rustc --version >/dev/null 2>&1 && exit 0 + echo "Installing Rust $channel (${profile:-default} profile) for the fresh base build" + rustup toolchain install "$channel" --profile "${profile:-default}" --no-self-update + - shell: bash env: CPU_LABEL: ${{ inputs.label }} From 840932ac564662bcfea7891ecf420212945b480d Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Tue, 1 Sep 2026 14:05:07 +0000 Subject: [PATCH 27/44] Verify native Plonky3 multiproofs recursively Consume the Plonky3 0.6 batch-opening layout directly in Aiur instead of expanding every pruned Merkle frontier into one authentication path per FRI query. Sample all query indices from the unchanged transcript, sort and deduplicate them with an O(q log q) merge sort, authenticate each input and commit-phase commitment once, then retain the existing per-query reduced-opening and FRI arithmetic. Bind every frontier to transcript-derived indices, consume boundary digests in Plonky3's level/parent/child order, reject trailing frontier elements and inconsistent duplicate leaves, and assert all native opening dimensions and sibling counts. Explicitly constrain the digest-bound protocol specialization to cap height 0, binary FRI, and a constant final polynomial. Move memo_u32_less_than into IxVM Core so both substitution and multiproof sorting share its constrained rows. Strengthen the recursive negative test to mutate a structurally valid stage-1 commitment. Regenerate both checked-in Aiur Rust executors and retain interpreter/codegen query-count parity. On Vector.extract_append q50, recursive-verifier FFT cost falls from 204.073B to 201.166B. CPU outer proving improves from 50.09s to 45.03s and the full CPU pipeline from 90.64s to 82.90s. GPU outer proving improves from 15.85s to 13.72s and the full GPU pipeline from 28.86s to 26.69s. The outer proof grows from 3.92 MB to 4.17 MB. Validated with the MultiStark primitive suite, recursive honest/tamper/parity tests, codegen --check, release workspace clippy, release CUDA clippy, rustfmt, and diff checks. --- Ix/IxVM/Core.lean | 10 + Ix/IxVM/Kernel/Subst.lean | 8 - Ix/MultiStark/Deserialize.lean | 93 +- Ix/MultiStark/Pcs.lean | 268 +- Ix/MultiStark/Verifier.lean | 12 +- Tests/MultiStark.lean | 12 +- crates/aiur/src/synthesis.rs | 15 +- crates/ixvm-codegen/src/aiur_ixvm.rs | 12144 +++++++++--------- crates/ixvm-codegen/src/aiur_multi_stark.rs | 9408 ++++++++------ 9 files changed, 11629 insertions(+), 10341 deletions(-) diff --git a/Ix/IxVM/Core.lean b/Ix/IxVM/Core.lean index a32e74d71..619ba613e 100644 --- a/Ix/IxVM/Core.lean +++ b/Ix/IxVM/Core.lean @@ -18,6 +18,16 @@ def core := ⟦ None } + -- Memoized u32 comparison for hot structural and frontier walks. Aiur + -- memoizes function calls automatically, so keeping the decomposition in + -- this shared helper avoids charging the wide intrinsic layout repeatedly; + -- recurring `(a, b)` pairs share one constrained helper row. This belongs + -- in Core because both the IxVM substitution circuits and the recursive + -- multi-STARK verifier rely on the same optimization. + fn memo_u32_less_than(a: G, b: G) -> G { + u32_less_than(a, b) + } + -- Interned 32-element address (blake3 content hash). -- -- DIFFERENT POINTER VALUES DO NOT IMPLY DIFFERENT DATA. The Aiur diff --git a/Ix/IxVM/Kernel/Subst.lean b/Ix/IxVM/Kernel/Subst.lean index 5250e5815..1a1b8bef9 100644 --- a/Ix/IxVM/Kernel/Subst.lean +++ b/Ix/IxVM/Kernel/Subst.lean @@ -90,14 +90,6 @@ def subst := ⟦ } } - -- Memoized structural comparison used by substitution fast paths. Keeping - -- the u32 decomposition in this helper avoids charging its wide intrinsic - -- layout on every row of a hot substitution circuit; repeated `(depth,lbr)` - -- pairs share one constrained helper row. - fn memo_u32_less_than(a: G, b: G) -> G { - u32_less_than(a, b) - } - -- ============================================================================ -- has_bvar_in_range -- diff --git a/Ix/MultiStark/Deserialize.lean b/Ix/MultiStark/Deserialize.lean index 96fcb9cbf..2a808d36d 100644 --- a/Ix/MultiStark/Deserialize.lean +++ b/Ix/MultiStark/Deserialize.lean @@ -79,34 +79,37 @@ def deserialize := ⟦ Mk(MerkleCap, MerkleCap, MerkleCap) } - -- `BatchOpening`: per-round input opening of a FRI query. - -- opened_values : Vec> (one row of base-field values per matrix) - -- opening_proof : Vec (Merkle authentication path) - enum BatchOpening { - Mk(List‹List‹U64››, List‹DigestP›) + -- One input commitment opened at all query indices with a shared pruned + -- Merkle frontier. `opened_values[q][m]` is query q's row of matrix m. + enum BatchMultiOpening { + Mk(List‹List‹List‹U64›››, List‹DigestP›) } -- `CommitPhaseProofStep`: one folding step of a FRI query. -- log_arity : u8 -- sibling_values : Vec (arity - 1 siblings) -- opening_proof : Vec - enum CommitPhaseProofStep { - Mk(U8, List‹Ext›, List‹DigestP›) + enum CommitPhaseMultiStep { + Mk(U8, List‹List‹Ext››, List‹DigestP›) } - -- `QueryProof>>`. - enum QueryProof { - Mk(List‹BatchOpening›, List‹CommitPhaseProofStep›) - } + -- Per-query views derived in-circuit from the native batch openings. They + -- retain the existing FRI arithmetic organization; authentication is done + -- once per native multiproof before that arithmetic runs. + enum BatchOpening { Mk(List‹List‹U64››) } + enum CommitPhaseProofStep { Mk(U8, List‹Ext›) } + enum QueryProof { Mk(List‹BatchOpening›, List‹CommitPhaseProofStep›) } -- `PcsProof = FriProof`. -- commit_phase_commits : Vec -- commit_pow_witnesses : Vec - -- query_proofs : Vec + -- input_openings : Vec + -- commit_phase_openings: Vec -- final_poly : Vec -- query_pow_witness : Val enum FriProof { - Mk(List‹MerkleCap›, List‹U64›, List‹QueryProof›, List‹Ext›, U64) + Mk(List‹MerkleCap›, List‹U64›, List‹BatchMultiOpening›, + List‹CommitPhaseMultiStep›, List‹Ext›, U64) } -- `Option` for `preprocessed_opened_values`. A dedicated @@ -301,6 +304,20 @@ def deserialize := ⟦ } } + fn read_u64_vec_vec_vec(i: G) -> (List‹List‹List‹U64›››, G) { + let (n, j) = read_count_at(i); + read_u64_vec_vec_vec_n(j, n) + } + fn read_u64_vec_vec_vec_n(i: G, n: G) -> (List‹List‹List‹U64›››, G) { + match n { + 0 => (store(ListNode.Nil), i), + _ => + let (x, j) = @read_u64_vec_vec(i); + let (rest, j2) = read_u64_vec_vec_vec_n(j, n - 1); + (store(ListNode.Cons(x, rest)), j2), + } + } + -- `OpenedRound = Vec>>`, built bottom-up from `read_ext_vec`. fn read_ext_vec_vec(i: G) -> (List‹List‹Ext››, G) { let (n, j) = read_count_at(i); @@ -358,16 +375,16 @@ def deserialize := ⟦ (Commitments.Mk(stage_1_trace, stage_2_trace, quotient_chunks), j2) } - fn read_batch_opening(i: G) -> (BatchOpening, G) { - let (opened_values, j0) = @read_u64_vec_vec(i); + fn read_batch_opening(i: G) -> (BatchMultiOpening, G) { + let (opened_values, j0) = @read_u64_vec_vec_vec(i); let (opening_proof, j1) = read_digest_vec_at(j0); - (BatchOpening.Mk(opened_values, opening_proof), j1) + (BatchMultiOpening.Mk(opened_values, opening_proof), j1) } - fn read_batch_opening_vec(i: G) -> (List‹BatchOpening›, G) { + fn read_batch_opening_vec(i: G) -> (List‹BatchMultiOpening›, G) { let (n, j) = read_count_at(i); read_batch_opening_vec_n(j, n) } - fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchOpening›, G) { + fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchMultiOpening›, G) { match n { 0 => (store(ListNode.Nil), i), _ => @@ -377,17 +394,17 @@ def deserialize := ⟦ } } - fn read_commit_phase_step(i: G) -> (CommitPhaseProofStep, G) { + fn read_commit_phase_step(i: G) -> (CommitPhaseMultiStep, G) { let (log_arity, j0) = #read_u8_at(i); - let (sibling_values, j1) = read_ext_vec(j0); + let (sibling_values, j1) = @read_ext_vec_vec(j0); let (opening_proof, j2) = read_digest_vec_at(j1); - (CommitPhaseProofStep.Mk(log_arity, sibling_values, opening_proof), j2) + (CommitPhaseMultiStep.Mk(log_arity, sibling_values, opening_proof), j2) } - fn read_commit_phase_step_vec(i: G) -> (List‹CommitPhaseProofStep›, G) { + fn read_commit_phase_step_vec(i: G) -> (List‹CommitPhaseMultiStep›, G) { let (n, j) = read_count_at(i); read_commit_phase_step_vec_n(j, n) } - fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseProofStep›, G) { + fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseMultiStep›, G) { match n { 0 => (store(ListNode.Nil), i), _ => @@ -397,33 +414,15 @@ def deserialize := ⟦ } } - fn read_query_proof(i: G) -> (QueryProof, G) { - let (input_proof, j0) = @read_batch_opening_vec(i); - let (commit_phase_openings, j1) = @read_commit_phase_step_vec(j0); - (QueryProof.Mk(input_proof, commit_phase_openings), j1) - } - fn read_query_proof_vec(i: G) -> (List‹QueryProof›, G) { - let (n, j) = read_count_at(i); - read_query_proof_vec_n(j, n) - } - fn read_query_proof_vec_n(i: G, n: G) -> (List‹QueryProof›, G) { - match n { - 0 => (store(ListNode.Nil), i), - _ => - let (x, j) = @read_query_proof(i); - let (rest, j2) = read_query_proof_vec_n(j, n - 1); - (store(ListNode.Cons(x, rest)), j2), - } - } - fn read_fri_proof(i: G) -> (FriProof, G) { let (commit_phase_commits, j0) = @read_merkle_cap_vec(i); let (commit_pow_witnesses, j1) = read_u64_vec(j0); - let (query_proofs, j2) = @read_query_proof_vec(j1); - let (final_poly, j3) = read_ext_vec(j2); - let (query_pow_witness, j4) = #read_u64_at(j3); - (FriProof.Mk(commit_phase_commits, commit_pow_witnesses, query_proofs, - final_poly, query_pow_witness), j4) + let (input_openings, j2) = @read_batch_opening_vec(j1); + let (commit_phase_openings, j3) = @read_commit_phase_step_vec(j2); + let (final_poly, j4) = read_ext_vec(j3); + let (query_pow_witness, j5) = #read_u64_at(j4); + (FriProof.Mk(commit_phase_commits, commit_pow_witnesses, input_openings, + commit_phase_openings, final_poly, query_pow_witness), j5) } -- The activation bitmap: `Vec` on the wire (u64 count, then one diff --git a/Ix/MultiStark/Pcs.lean b/Ix/MultiStark/Pcs.lean index 82a147c20..9ac8b4c65 100644 --- a/Ix/MultiStark/Pcs.lean +++ b/Ix/MultiStark/Pcs.lean @@ -515,6 +515,129 @@ def pcs := ⟦ eq_zero(ptr_val(list_lookup(cap, capidx)) - ptr_val(root)) } + -- A node in the sorted multiproof frontier. Rows are retained from the + -- lead query so shorter matrices can be injected at their native height. + enum FrontierNode { Mk(G, List‹G›, List‹List‹U64››, DigestP) } + + fn frontier_merge(xs: List‹FrontierNode›, ys: List‹FrontierNode›) -> List‹FrontierNode› { + match load(xs) { + ListNode.Nil => ys, + ListNode.Cons(x, xrest) => match load(ys) { + ListNode.Nil => xs, + ListNode.Cons(y, yrest) => + let FrontierNode.Mk(xi, _xb, _xr, xd) = x; + let FrontierNode.Mk(yi, _yb, _yr, yd) = y; + match memo_u32_less_than(xi, yi) { + 1 => store(ListNode.Cons(x, frontier_merge(xrest, ys))), + _ => match eq_zero(xi - yi) { + 1 => + -- Duplicate transcript queries must open the same leaf. A + -- direct pointer assertion is sound here: only equality is + -- accepted; non-canonical equal digests can at worst reject. + assert_eq!(ptr_val(xd), ptr_val(yd)); + store(ListNode.Cons(x, frontier_merge(xrest, yrest))), + _ => store(ListNode.Cons(y, frontier_merge(xs, yrest))), + }, + }, + }, + } + } + + -- Deal alternating elements into two half-sized lists. Their internal order + -- is irrelevant because each half is recursively sorted before merging. + fn frontier_split(xs: List‹FrontierNode›) -> (List‹FrontierNode›, List‹FrontierNode›) { + match load(xs) { + ListNode.Nil => (store(ListNode.Nil), store(ListNode.Nil)), + ListNode.Cons(x, rest) => match load(rest) { + ListNode.Nil => (store(ListNode.Cons(x, store(ListNode.Nil))), store(ListNode.Nil)), + ListNode.Cons(y, tail) => + let (left, right) = frontier_split(tail); + (store(ListNode.Cons(x, left)), store(ListNode.Cons(y, right))), + }, + } + } + + fn frontier_sort(xs: List‹FrontierNode›) -> List‹FrontierNode› { + match load(xs) { + ListNode.Nil => xs, + ListNode.Cons(_x, rest) => match load(rest) { + ListNode.Nil => xs, + ListNode.Cons(_y, _tail) => + let (left, right) = frontier_split(xs); + frontier_merge(frontier_sort(left), frontier_sort(right)), + }, + } + } + + fn frontier_leaves(indices: List‹List‹G››, rows: List‹List‹List‹U64›››, + lhs: List‹G›, log_max: G) -> List‹FrontierNode› { + match load(indices) { + ListNode.Nil => + assert_eq!(list_length(rows), 0); + store(ListNode.Nil), + ListNode.Cons(bits, irest) => + let &ListNode.Cons(r, rrest) = rows; + let d = leaf_hash_at(r, lhs, log_max); + store(ListNode.Cons(FrontierNode.Mk(bits_to_num(bits), bits, r, d), + frontier_leaves(irest, rrest, lhs, log_max))), + } + } + + -- Fold one binary frontier level. Boundary siblings are consumed in the + -- exact ascending-parent/ascending-child order used by Plonky3 pruning. + fn frontier_level(nodes: List‹FrontierNode›, proof: List‹DigestP›, + lhs: List‹G›, next_lh: G) -> (List‹FrontierNode›, List‹DigestP›) { + match load(nodes) { + ListNode.Nil => (store(ListNode.Nil), proof), + ListNode.Cons(a, rest) => + let FrontierNode.Mk(ai, abits, ar, ad) = a; + let &ListNode.Cons(abit, aparent_bits) = abits; + let aparent = bits_to_num(aparent_bits); + match load(rest) { + ListNode.Cons(b, brest) => + let FrontierNode.Mk(bi, bbits, _br, bd) = b; + let &ListNode.Cons(_bbit, bparent_bits) = bbits; + match eq_zero(aparent - bits_to_num(bparent_bits)) { + 1 => + let parent = inject_maybe(ar, lhs, next_lh, mmcs_compress(ad, bd)); + let (tail, p2) = frontier_level(brest, proof, lhs, next_lh); + (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), tail)), p2), + _ => + let &ListNode.Cons(sib, prest) = proof; + let parent = inject_maybe(ar, lhs, next_lh, compress_ordered(abit, ad, sib)); + let (tail, p2) = frontier_level(rest, prest, lhs, next_lh); + (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), tail)), p2), + }, + ListNode.Nil => + let &ListNode.Cons(sib, prest) = proof; + let parent = inject_maybe(ar, lhs, next_lh, compress_ordered(abit, ad, sib)); + (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), store(ListNode.Nil))), prest), + }, + } + } + + fn frontier_fold(nodes: List‹FrontierNode›, proof: List‹DigestP›, + lhs: List‹G›, levels: G) -> (List‹FrontierNode›, List‹DigestP›) { + match levels { + 0 => (nodes, proof), + _ => + let (next, p2) = frontier_level(nodes, proof, lhs, levels - 1); + frontier_fold(next, p2, lhs, levels - 1), + } + } + + fn mmcs_verify_multi(cap: MerkleCap, rows: List‹List‹List‹U64›››, + lhs: List‹G›, indices: List‹List‹G››, proof: List‹DigestP›, log_max: G) -> G { + assert_eq!(eq_zero(list_length(rows) - list_length(indices)), 1); + let leaves = frontier_sort(frontier_leaves(indices, rows, lhs, log_max)); + let (roots, rest) = frontier_fold(leaves, proof, lhs, log_max); + assert_eq!(list_length(rest), 0); + let &ListNode.Cons(root, no_more) = roots; + assert_eq!(list_length(no_more), 0); + let FrontierNode.Mk(capidx, _bits, _rows, digest) = root; + eq_zero(ptr_val(list_lookup(cap, capidx)) - ptr_val(digest)) + } + -- ========================================================================== -- FRI fold step (`TwoAdicFriFolding::fold_row`, arity-2 case). -- @@ -826,7 +949,7 @@ def pcs := ⟦ match prep_opt { PreprocessedOpt.NoPreprocessed => buckets, PreprocessedOpt.SomePreprocessed(prep_round) => - let BatchOpening.Mk(rows_p, proof_p) = list_lookup(input_proof, 3); + let BatchOpening.Mk(rows_p) = list_lookup(input_proof, 3); -- one opened base row per preprocessed matrix (BatchOpenedValuesCountMismatch) assert_eq!(eq_zero(list_length(rows_p) - list_length(prep_round)), 1); -- The preprocessed tree's max height is over the PREP circuits only, so @@ -836,8 +959,6 @@ def pcs := ⟦ -- of the LSB-first bit list) and verify against the batch's own height. let prep_heights = heights_prep(log_degrees, log_blowup, prep_indices, num_circuits, 0); let log_pmax = heights_max(prep_heights); - assert_eq!(mmcs_verify(prep_commit, rows_p, prep_heights, - list_drop(idxbits, log_gmax - log_pmax), proof_p, log_pmax), 1); open_prep(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, 0, log_degrees, prep_indices, zeta, rows_p, prep_round, alpha), } @@ -904,7 +1025,7 @@ def pcs := ⟦ } fn verify_query(folded: Ext, betas: List‹Ext›, comms: List‹MerkleCap›, openings: List‹CommitPhaseProofStep›, domidx: List‹G›, log_cur: G, - ro_rest: List‹Bucket›, log_final: G) -> Ext { + ro_rest: List‹Bucket›, log_final: G) -> (Ext, List‹List‹U64››) { match load(openings) { ListNode.Nil => -- must have folded down to exactly the final domain size, and every @@ -912,22 +1033,20 @@ def pcs := ⟦ -- UnconsumedReducedOpenings). assert_eq!(eq_zero(log_cur - log_final), 1); assert_eq!(list_length(ro_rest), 0); - folded, + (folded, store(ListNode.Nil)), ListNode.Cons(op, op_rest) => let &ListNode.Cons(beta, beta_rest) = betas; let &ListNode.Cons(comm, comm_rest) = comms; - let CommitPhaseProofStep.Mk(_la, sibs, oproof) = op; + let CommitPhaseProofStep.Mk(_la, sibs) = op; -- arity 2 ⇒ exactly arity-1 = 1 sibling (SiblingValuesLengthMismatch). assert_eq!(list_length(sibs), 1); let &ListNode.Cons(ibit, idrest) = domidx; -- index_in_group = LSB let log_folded = log_cur - 1; let (e0, e1) = @recon_evals(ibit, folded, list_lookup(sibs, 0)); - -- authenticate the sibling pair against this round's commitment - assert_eq!(mmcs_verify(comm, store(ListNode.Cons(@flatten2(e0, e1), store(ListNode.Nil))), - store(ListNode.Cons(log_folded, store(ListNode.Nil))), idrest, oproof, log_folded), 1); let folded1 = fri_fold2(idrest, log_folded, beta, e0, e1); let (folded2, ro_rest2) = rollin(folded1, log_folded, beta, ro_rest); - verify_query(folded2, beta_rest, comm_rest, op_rest, idrest, log_folded, ro_rest2, log_final), + let (result, rows) = verify_query(folded2, beta_rest, comm_rest, op_rest, idrest, log_folded, ro_rest2, log_final); + (result, store(ListNode.Cons(@flatten2(e0, e1), rows))), } } @@ -941,7 +1060,7 @@ def pcs := ⟦ prep_commit: MerkleCap, prep_indices: List‹OptIdx›, log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, log_gmax: G, betas: List‹Ext›, commit_phase_commits: List‹MerkleCap›, final_poly: List‹Ext›, - num_rounds: G) -> G { + num_rounds: G) -> List‹List‹U64›› { let QueryProof.Mk(input_proof, commit_phase_openings) = qp; -- one commit-phase opening per round (QueryCommitPhaseOpeningsCountMismatch), -- one input batch per commitment (InputProofBatchCountMismatch). @@ -951,19 +1070,16 @@ def pcs := ⟦ -- one heights list for all three stage batches (memoized anyway; this -- also drops two call-output columns per proof) let hall = heights_all(log_degrees, log_blowup, num_circuits, 0); - let BatchOpening.Mk(rows_s1, proof_s1) = list_lookup(input_proof, 0); + let BatchOpening.Mk(rows_s1) = list_lookup(input_proof, 0); assert_eq!(eq_zero(list_length(rows_s1) - num_circuits), 1); - assert_eq!(mmcs_verify(s1c, rows_s1, hall, idxbits, proof_s1, log_gmax), 1); let buckets = open_batch_2pt(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_s1, stage1, alpha); - let BatchOpening.Mk(rows_s2, proof_s2) = list_lookup(input_proof, 1); + let BatchOpening.Mk(rows_s2) = list_lookup(input_proof, 1); assert_eq!(eq_zero(list_length(rows_s2) - num_circuits), 1); - assert_eq!(mmcs_verify(s2c, rows_s2, hall, idxbits, proof_s2, log_gmax), 1); let buckets = open_batch_2pt(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_s2, stage2, alpha); - let BatchOpening.Mk(rows_q, proof_q) = list_lookup(input_proof, 2); + let BatchOpening.Mk(rows_q) = list_lookup(input_proof, 2); -- one wide quotient matrix per circuit, on the trace domain, so the -- quotient batch's heights are the same per-circuit heights as the stages assert_eq!(eq_zero(list_length(rows_q) - num_circuits), 1); - assert_eq!(mmcs_verify(qc, rows_q, hall, idxbits, proof_q, log_gmax), 1); let buckets = open_quotient(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_q, q_opened, alpha); let buckets = open_prep_batch(buckets, input_proof, prep_commit, prep_opt, prep_indices, log_degrees, num_circuits, idxbits, log_gmax, log_blowup, zeta, alpha); -- a height-`log_blowup` (constant-poly) reduced opening must be zero @@ -973,10 +1089,10 @@ def pcs := ⟦ let &ListNode.Cons(b0, ro_rest) = buckets; let Bucket.Mk(h0, _ap0, folded_start) = b0; assert_eq!(eq_zero(h0 - log_gmax), 1); - let folded = verify_query(folded_start, betas, commit_phase_commits, commit_phase_openings, idxbits, log_gmax, ro_rest, log_blowup); + let (folded, fri_rows) = verify_query(folded_start, betas, commit_phase_commits, commit_phase_openings, idxbits, log_gmax, ro_rest, log_blowup); -- final check: with log_final_poly_len = 0, eval = final_poly[0] assert_eq!(@eg_eq(list_lookup(final_poly, 0), folded), 1); - 1 + fri_rows } -- Loop over all `num_queries` query proofs, sampling one index per query @@ -987,17 +1103,106 @@ def pcs := ⟦ prep_commit: MerkleCap, prep_indices: List‹OptIdx›, log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, log_gmax: G, betas: List‹Ext›, commit_phase_commits: List‹MerkleCap›, final_poly: List‹Ext›, - num_rounds: G) -> G { + num_rounds: G) -> List‹List‹List‹U64››› { match load(query_proofs) { - ListNode.Nil => 1, + ListNode.Nil => store(ListNode.Nil), ListNode.Cons(qp, rest) => let (idxbits, input2, output2) = ch_sample_bits(input, output, log_gmax); - let _q = verify_one_query(idxbits, qp, alpha, stage1, stage2, q_opened, prep_opt, + let qrows = verify_one_query(idxbits, qp, alpha, stage1, stage2, q_opened, prep_opt, s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds); - query_loop(input2, output2, rest, alpha, stage1, stage2, q_opened, prep_opt, + store(ListNode.Cons(qrows, query_loop(input2, output2, rest, alpha, stage1, stage2, q_opened, prep_opt, s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits, - log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds), + log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds))), + } + } + + fn sample_query_indices(input: ByteStream, output: ByteStream, n: G, + log_gmax: G) -> List‹List‹G›› { + match n { + 0 => store(ListNode.Nil), + _ => + let (bits, input2, output2) = ch_sample_bits(input, output, log_gmax); + store(ListNode.Cons(bits, sample_query_indices(input2, output2, n - 1, log_gmax))), + } + } + + fn batch_views_at(bs: List‹BatchMultiOpening›, q: G) -> List‹BatchOpening› { + match load(bs) { + ListNode.Nil => store(ListNode.Nil), + ListNode.Cons(b, rest) => + let BatchMultiOpening.Mk(rows, _proof) = b; + store(ListNode.Cons(BatchOpening.Mk(list_lookup(rows, q)), batch_views_at(rest, q))), + } + } + fn step_views_at(ss: List‹CommitPhaseMultiStep›, q: G) -> List‹CommitPhaseProofStep› { + match load(ss) { + ListNode.Nil => store(ListNode.Nil), + ListNode.Cons(s, rest) => + let CommitPhaseMultiStep.Mk(la, sibs, _proof) = s; + store(ListNode.Cons(CommitPhaseProofStep.Mk(la, list_lookup(sibs, q)), step_views_at(rest, q))), + } + } + fn query_views(bs: List‹BatchMultiOpening›, ss: List‹CommitPhaseMultiStep›, + q: G, n: G) -> List‹QueryProof› { + match n { + 0 => store(ListNode.Nil), + _ => store(ListNode.Cons(QueryProof.Mk(batch_views_at(bs, q), step_views_at(ss, q)), + query_views(bs, ss, q + 1, n - 1))), + } + } + + fn verify_input_multi(bs: List‹BatchMultiOpening›, indices: List‹List‹G››, + s1c: MerkleCap, s2c: MerkleCap, qc: MerkleCap, prep_commit: MerkleCap, + prep_opt: PreprocessedOpt, prep_indices: List‹OptIdx›, log_degrees: List‹U8›, + num_circuits: G, log_blowup: G, log_gmax: G) -> G { + let hall = heights_all(log_degrees, log_blowup, num_circuits, 0); + let BatchMultiOpening.Mk(s1rows, s1proof) = list_lookup(bs, 0); + let BatchMultiOpening.Mk(s2rows, s2proof) = list_lookup(bs, 1); + let BatchMultiOpening.Mk(qrows, qproof) = list_lookup(bs, 2); + assert_eq!(mmcs_verify_multi(s1c, s1rows, hall, indices, s1proof, log_gmax), 1); + assert_eq!(mmcs_verify_multi(s2c, s2rows, hall, indices, s2proof, log_gmax), 1); + assert_eq!(mmcs_verify_multi(qc, qrows, hall, indices, qproof, log_gmax), 1); + match prep_opt { + PreprocessedOpt.NoPreprocessed => 1, + PreprocessedOpt.SomePreprocessed(_round) => + let BatchMultiOpening.Mk(prows, pproof) = list_lookup(bs, 3); + let ph = heights_prep(log_degrees, log_blowup, prep_indices, num_circuits, 0); + let lp = heights_max(ph); + let pindices = drop_index_bits(indices, log_gmax - lp); + mmcs_verify_multi(prep_commit, prows, ph, pindices, pproof, lp), + } + } + fn drop_index_bits(indices: List‹List‹G››, n: G) -> List‹List‹G›› { + match load(indices) { + ListNode.Nil => indices, + ListNode.Cons(bits, rest) => + store(ListNode.Cons(list_drop(bits, n), drop_index_bits(rest, n))), + } + } + fn rows_at_round(rows: List‹List‹List‹U64›››, r: G) -> List‹List‹List‹U64››› { + match load(rows) { + ListNode.Nil => store(ListNode.Nil), + ListNode.Cons(qrows, rest) => + store(ListNode.Cons(store(ListNode.Cons(list_lookup(qrows, r), store(ListNode.Nil))), + rows_at_round(rest, r))), + } + } + fn verify_commit_multi(steps: List‹CommitPhaseMultiStep›, comms: List‹MerkleCap›, + all_rows: List‹List‹List‹U64›››, indices: List‹List‹G››, r: G, + log_cur: G) -> G { + match load(steps) { + ListNode.Nil => eq_zero(list_length(comms)), + ListNode.Cons(s, srest) => + let &ListNode.Cons(c, crest) = comms; + let CommitPhaseMultiStep.Mk(la, sibs, proof) = s; + assert_eq!(to_field(la), 1); + assert_eq!(list_length(sibs), list_length(indices)); + let next_indices = drop_index_bits(indices, 1); + let lh = log_cur - 1; + assert_eq!(mmcs_verify_multi(c, rows_at_round(all_rows, r), + store(ListNode.Cons(lh, store(ListNode.Nil))), next_indices, proof, lh), 1); + verify_commit_multi(srest, crest, all_rows, next_indices, r + 1, lh), } } @@ -1010,12 +1215,14 @@ def pcs := ⟦ prep_indices: List‹OptIdx›, log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, num_queries: G, commit_pow_bits: G, query_pow_bits: G) -> G { - let FriProof.Mk(commit_phase_commits, pw, query_proofs, final_poly, qpw) = opening; + let FriProof.Mk(commit_phase_commits, pw, input_openings, commit_phase_openings, + final_poly, qpw) = opening; let num_rounds = list_length(commit_phase_commits); -- FRI shape: one PoW witness per round, num_queries query proofs, and (since -- log_final_poly_len = 0) a single final-poly coefficient. assert_eq!(eq_zero(list_length(pw) - num_rounds), 1); - assert_eq!(eq_zero(list_length(query_proofs) - num_queries), 1); + assert_eq!(list_length(input_openings), 3 + prep_count(prep_opt)); + assert_eq!(eq_zero(list_length(commit_phase_openings) - num_rounds), 1); assert_eq!(list_length(final_poly), 1); -- challenger continuation: observe all opened values (coms_to_verify -- order), built as one front-to-back suffix + a single concat (the input @@ -1041,9 +1248,14 @@ def pcs := ⟦ -- max height so `two_adic_gen`'s squaring chain (bits ≤ 32) and the -- 32-bit query-index decomposition stay within range. assert_eq!(u32_less_than(log_gmax, 33), 1); - query_loop(input, output, query_proofs, alpha, stage1, stage2, q_opened, + let indices = sample_query_indices(input, output, num_queries, log_gmax); + assert_eq!(verify_input_multi(input_openings, indices, s1c, s2c, qc, + prep_commit, prep_opt, prep_indices, log_degrees, num_circuits, log_blowup, log_gmax), 1); + let query_proofs = query_views(input_openings, commit_phase_openings, 0, num_queries); + let fri_rows = query_loop(input, output, query_proofs, alpha, stage1, stage2, q_opened, prep_opt, s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, - num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds) + num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds); + verify_commit_multi(commit_phase_openings, commit_phase_commits, fri_rows, indices, 0, log_gmax) } ⟧ diff --git a/Ix/MultiStark/Verifier.lean b/Ix/MultiStark/Verifier.lean index b11b6a79e..5e72fd32c 100644 --- a/Ix/MultiStark/Verifier.lean +++ b/Ix/MultiStark/Verifier.lean @@ -871,9 +871,17 @@ def verifier := ⟦ -- `query_pow_bits`) all come from the verifying key, which the public -- statement binds through `system_digest` — no separate public inputs. let Sys.Mk(params, tlimbs, circuits, commit, prep_indices) = sys; - let SysParams.Mk(log_blowup, _cap_height, _log_final_poly_len, - _max_log_arity, num_queries, commit_pow_bits, + let SysParams.Mk(log_blowup, cap_height, log_final_poly_len, + max_log_arity, num_queries, commit_pow_bits, query_pow_bits) = params; + -- This recursive verifier is deliberately specialized to root caps, + -- binary FRI folds, and a constant final polynomial. These parameters are + -- digest-bound but still prover-visible inputs to this circuit, so reject + -- unsupported systems explicitly instead of silently applying the wrong + -- Merkle geometry or folding semantics. + assert_eq!(cap_height, 0); + assert_eq!(log_final_poly_len, 0); + assert_eq!(max_log_arity, 1); let Proof.Mk(active, commitments, accs, log_degrees, opening, q_opened, prep_opt, stage1, stage2) = proof; -- Sparse activation: the bitmap covers the canonical circuit set; diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index 4e36fa670..b62c08414 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -189,10 +189,16 @@ def endToEndSuite : IO UInt32 := do | none => IO.eprintln "verify_multi_stark_proof entrypoint not found"; return 1 -- ── negative-test inputs ──────────────────────────────────────────────────── - -- Tampered proof advice: flip byte 0 (the first stage_1-commitment limb) so the - -- replayed Fiat-Shamir transcript diverges from the one the proof was made under. + -- Tampered proof advice: locate the first stage-1 commitment byte after the + -- native proof's `Vec` activation bitmap and cap-length prefix. This + -- keeps the proof structurally parseable while forcing Fiat-Shamir and the + -- Merkle checks away from the proof that was actually produced. + let activeLen := (List.range 8).foldl (fun n i => + n ||| (proofBytes.data[i]!.toUInt64 <<< (i * 8).toUInt64)) 0 + let firstCommitByte := 8 + activeLen.toNat + 8 let badProofBytes := - proofBytes.set! 0 (UInt8.ofNat ((proofBytes.data[0]!.toNat + 1) % 256)) + proofBytes.set! firstCommitByte + (UInt8.ofNat ((proofBytes.data[firstCommitByte]!.toNat + 1) % 256)) -- Tampered claim (with a matching keccak digest): 120 → 121. Feeds a different -- value into Fiat-Shamir (→ different ζ) and the lookup accumulator, so the -- composition/quotient identity no longer holds even though the binding passes. diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 70e598184..1bfec2b9d 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -444,20 +444,17 @@ impl AiurSystem { self.system.verify(claim, proof) } - /// Re-encode a verified proof into the per-query authentication-path - /// transport consumed by the in-circuit recursive verifier. + /// Verify and serialize the native Plonky3 multiproof for the in-circuit + /// recursive verifier. pub fn proof_to_advice_bytes( &self, claim: &[G], proof: &AiurProof, ) -> Result, multi_stark::advice::AdviceError> { - multi_stark::advice::proof_to_advice_bytes( - &self.system, - self.commitment_parameters, - self.fri_parameters, - &[claim], - proof, - ) + self.verify(claim, proof).map_err(|e| { + multi_stark::advice::AdviceError::Verification(format!("{e:?}")) + })?; + proof.to_bytes().map_err(multi_stark::advice::AdviceError::Encode) } } diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index e0b23dee8..f2e10bc6b 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -25,6 +25,25 @@ 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 __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __ret: [G; OUT_0] = [__v_2]; + if 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]; @@ -266,61 +285,61 @@ fn aiur_fn_0( match __v_226.as_canonical_u64() { 0u64 => { let __v_227: G = G::from_u64(1); - let __ret: [G; OUT_0] = [__v_227]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_227]; + if 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_227: G = G::from_u64(0); - let __ret: [G; OUT_0] = [__v_227]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_227]; + if 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_214: G = G::from_u64(0); - let __ret: [G; OUT_0] = [__v_214]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_214]; + if 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_177: G = G::from_u64(0); - let __ret: [G; OUT_0] = [__v_177]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_177]; + if 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_140: G = G::from_u64(0); - let __ret: [G; OUT_0] = [__v_140]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_140]; + if 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_103: G = G::from_u64(0); - let __ret: [G; OUT_0] = [__v_103]; - if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_1] = [__v_103]; + if 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_1: usize = 2; -const IN_1: usize = 2; -const OUT_1: usize = 1; -fn aiur_fn_1( - inp: [G; IN_1], +const INPUT_SIZE_2: usize = 2; +const IN_2: usize = 2; +const OUT_2: usize = 1; +fn aiur_fn_2( + inp: [G; IN_2], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_1], ExecError> { +) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -393,31 +412,31 @@ fn aiur_fn_1( let __v_66: G = (__v_2 - __v_34); match __v_66.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; 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_67: G = __r_arr[0]; - let __ret: [G; OUT_1] = [__v_67]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_67]; + if 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_67: G = G::from_u64(0); - let __ret: [G; OUT_1] = [__v_67]; - if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_2] = [__v_67]; + if 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_2: usize = 3; -const IN_2: usize = 3; -const OUT_2: usize = 1; -fn aiur_fn_2( - inp: [G; IN_2], +const INPUT_SIZE_3: usize = 3; +const IN_3: usize = 3; +const OUT_3: usize = 1; +fn aiur_fn_3( + inp: [G; IN_3], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_2], ExecError> { +) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -427,8 +446,8 @@ fn aiur_fn_2( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_2] = [__v_5]; - if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_3] = [__v_5]; + 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); }, _ => { @@ -436,29 +455,29 @@ fn aiur_fn_2( let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 - __v_5); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; 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_7: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_8: G = __io_read[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_2] = [__v_10]; - if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_3] = [__v_10]; + 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_3: usize = 8; -const IN_3: usize = 8; -const OUT_3: usize = 1; -fn aiur_fn_3( - inp: [G; IN_3], +const INPUT_SIZE_4: usize = 8; +const IN_4: usize = 8; +const OUT_4: usize = 1; +fn aiur_fn_4( + inp: [G; IN_4], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_3], ExecError> { +) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -483,14 +502,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -499,14 +518,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -519,14 +538,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -535,14 +554,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -559,14 +578,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -575,14 +594,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -595,14 +614,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -611,14 +630,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -639,14 +658,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(4); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -655,14 +674,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -675,14 +694,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -691,14 +710,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -715,14 +734,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -731,14 +750,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -751,14 +770,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -767,14 +786,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -799,14 +818,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(3); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -815,14 +834,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -835,14 +854,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -851,14 +870,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -875,14 +894,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -891,14 +910,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -911,14 +930,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -927,14 +946,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -955,14 +974,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(4); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -971,14 +990,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -991,14 +1010,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1007,14 +1026,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1031,14 +1050,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1047,14 +1066,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1067,14 +1086,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1083,14 +1102,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1119,14 +1138,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1135,14 +1154,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1155,14 +1174,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1171,14 +1190,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1195,14 +1214,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1211,14 +1230,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1231,14 +1250,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1247,14 +1266,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1275,14 +1294,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(4); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1291,14 +1310,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1311,14 +1330,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1327,14 +1346,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1351,14 +1370,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1367,14 +1386,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1387,14 +1406,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1403,14 +1422,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1435,14 +1454,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(3); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1451,14 +1470,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1471,14 +1490,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1487,14 +1506,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1511,14 +1530,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1527,14 +1546,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1547,14 +1566,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1563,14 +1582,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1591,14 +1610,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(4); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1607,14 +1626,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1627,14 +1646,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1643,14 +1662,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1667,14 +1686,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1683,14 +1702,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1703,14 +1722,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(6); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1719,14 +1738,14 @@ fn aiur_fn_3( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(7); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(8); - let __ret: [G; OUT_3] = [__v_8]; - if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_4] = [__v_8]; + if 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); }, } @@ -1745,15 +1764,15 @@ fn aiur_fn_3( }) } -const INPUT_SIZE_4: usize = 8; -const IN_4: usize = 8; -const OUT_4: usize = 1; -fn aiur_fn_4( - inp: [G; IN_4], +const INPUT_SIZE_5: usize = 8; +const IN_5: usize = 8; +const OUT_5: usize = 1; +fn aiur_fn_5( + inp: [G; IN_5], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_4], ExecError> { +) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1780,85 +1799,85 @@ fn aiur_fn_4( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if 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); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if 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); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if 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); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if 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); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if 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); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if 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); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if 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); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if 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); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_4] = [__v_8]; - if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_5] = [__v_8]; + if 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_5: usize = 8; -const IN_5: usize = 8; -const OUT_5: usize = 4; -fn aiur_fn_5( - inp: [G; IN_5], +const INPUT_SIZE_6: usize = 8; +const IN_6: usize = 8; +const OUT_6: usize = 4; +fn aiur_fn_6( + inp: [G; IN_6], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_5], ExecError> { +) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1881,21 +1900,21 @@ fn aiur_fn_5( if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_6] = [__v_8, __v_9, __v_10, __v_11]; + if 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_6: usize = 12; -const IN_6: usize = 12; -const OUT_6: usize = 4; -fn aiur_fn_6( - inp: [G; IN_6], +const INPUT_SIZE_7: usize = 12; +const IN_7: usize = 12; +const OUT_7: usize = 4; +fn aiur_fn_7( + inp: [G; IN_7], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_6], ExecError> { +) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1928,21 +1947,21 @@ fn aiur_fn_6( if (__v_22 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __ret: [G; OUT_6] = [__v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[6].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_7] = [__v_12, __v_13, __v_14, __v_15]; + if 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_7: usize = 8; -const IN_7: usize = 8; -const OUT_7: usize = 4; -fn aiur_fn_7( - inp: [G; IN_7], +const INPUT_SIZE_8: usize = 8; +const IN_8: usize = 8; +const OUT_8: usize = 4; +fn aiur_fn_8( + inp: [G; IN_8], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_7], ExecError> { +) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1956,27 +1975,7 @@ fn aiur_fn_7( let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) }; let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) }; let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; - let __ret: [G; OUT_7] = [__v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[7].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - 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_2, __v_3, __v_0, __v_1]; + let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11]; 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); }) @@ -1996,14 +1995,14 @@ fn aiur_fn_9( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __ret: [G; OUT_9] = [__v_1, __v_2, __v_3, __v_0]; + let __ret: [G; OUT_9] = [__v_2, __v_3, __v_0, __v_1]; 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 INPUT_SIZE_10: usize = 4; +const IN_10: usize = 4; const OUT_10: usize = 4; fn aiur_fn_10( inp: [G; IN_10], @@ -2011,6 +2010,26 @@ fn aiur_fn_10( 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 __ret: [G; OUT_10] = [__v_1, __v_2, __v_3, __v_0]; + 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 = 4; +fn aiur_fn_11( + inp: [G; IN_11], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2036,21 +2055,21 @@ fn aiur_fn_10( let __v_17: G = (__v_10 + __v_13); let __v_18: G = (__v_12 + __v_15); let __v_19: G = (__v_14 + __v_9); - let __ret: [G; OUT_10] = [__v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19]; + if 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_11: usize = 8; -const IN_11: usize = 8; -const OUT_11: usize = 4; -fn aiur_fn_11( - inp: [G; IN_11], +const INPUT_SIZE_12: usize = 8; +const IN_12: usize = 8; +const OUT_12: usize = 4; +fn aiur_fn_12( + inp: [G; IN_12], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_11], ExecError> { +) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2076,21 +2095,21 @@ fn aiur_fn_11( let __v_17: G = (__v_12 + __v_15); let __v_18: G = (__v_14 + __v_9); let __v_19: G = (__v_8 + __v_11); - let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_12] = [__v_16, __v_17, __v_18, __v_19]; + if 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_12: usize = 16; -const IN_12: usize = 16; -const OUT_12: usize = 1; -fn aiur_fn_12( - inp: [G; IN_12], +const INPUT_SIZE_13: usize = 16; +const IN_13: usize = 16; +const OUT_13: usize = 1; +fn aiur_fn_13( + inp: [G; IN_13], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_12], ExecError> { +) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2133,85 +2152,85 @@ fn aiur_fn_12( match __v_23.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if 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); }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if 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); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if 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); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if 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); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if 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); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if 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); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if 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); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if 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); }, } }, _ => { let __v_24: G = G::from_u64(0); - let __ret: [G; OUT_12] = [__v_24]; - if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_13] = [__v_24]; + if 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_13: usize = 16; -const IN_13: usize = 16; -const OUT_13: usize = 9; -fn aiur_fn_13( - inp: [G; IN_13], +const INPUT_SIZE_14: usize = 16; +const IN_14: usize = 16; +const OUT_14: usize = 9; +fn aiur_fn_14( + inp: [G; IN_14], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_13], ExecError> { +) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2281,21 +2300,21 @@ fn aiur_fn_13( let __v_50: G = __b2_add.0; let __v_51: G = __b2_add.1; let __v_52: G = (__v_49 + __v_51); - let __ret: [G; OUT_13] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; - if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_14] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; + if 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_14: usize = 8; -const IN_14: usize = 8; -const OUT_14: usize = 8; -fn aiur_fn_14( - inp: [G; IN_14], +const INPUT_SIZE_15: usize = 8; +const IN_15: usize = 8; +const OUT_15: usize = 8; +fn aiur_fn_15( + inp: [G; IN_15], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_14], ExecError> { +) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2329,8 +2348,8 @@ fn aiur_fn_14( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + if 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); }, _ => { @@ -2343,8 +2362,8 @@ fn aiur_fn_14( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_7 + __v_15); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; + if 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); }, } @@ -2358,8 +2377,8 @@ fn aiur_fn_14( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_6 + __v_14); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; + if 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); }, } @@ -2372,8 +2391,8 @@ fn aiur_fn_14( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; + if 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); }, } @@ -2385,8 +2404,8 @@ fn aiur_fn_14( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 + __v_12); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; + if 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); }, } @@ -2397,8 +2416,8 @@ fn aiur_fn_14( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 + __v_11); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; + if 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); }, } @@ -2408,8 +2427,8 @@ fn aiur_fn_14( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __ret: [G; OUT_14] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; + if 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); }, } @@ -2418,8 +2437,8 @@ fn aiur_fn_14( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 + __v_9); - let __ret: [G; OUT_14] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + if 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); }, } @@ -2427,23 +2446,23 @@ fn aiur_fn_14( _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 + __v_8); - let __ret: [G; OUT_14] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_15] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + if 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_15: usize = 8; -const IN_15: usize = 8; -const OUT_15: usize = 8; -fn aiur_fn_15( - inp: [G; IN_15], +const INPUT_SIZE_16: usize = 8; +const IN_16: usize = 8; +const OUT_16: usize = 8; +fn aiur_fn_16( + inp: [G; IN_16], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_15], ExecError> { +) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2477,8 +2496,8 @@ fn aiur_fn_15( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + if 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); }, _ => { @@ -2491,8 +2510,8 @@ fn aiur_fn_15( let __v_14: G = G::from_u64(255); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_7 - __v_15); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; + if 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); }, } @@ -2506,8 +2525,8 @@ fn aiur_fn_15( let __v_13: G = G::from_u64(255); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_6 - __v_14); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; + if 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); }, } @@ -2520,8 +2539,8 @@ fn aiur_fn_15( let __v_12: G = G::from_u64(255); let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 - __v_13); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; + if 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); }, } @@ -2533,8 +2552,8 @@ fn aiur_fn_15( let __v_11: G = G::from_u64(255); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 - __v_12); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; + if 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); }, } @@ -2545,8 +2564,8 @@ fn aiur_fn_15( let __v_10: G = G::from_u64(255); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 - __v_11); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; + if 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); }, } @@ -2556,8 +2575,8 @@ fn aiur_fn_15( let __v_9: G = G::from_u64(255); let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); - let __ret: [G; OUT_15] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; + if 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); }, } @@ -2566,8 +2585,8 @@ fn aiur_fn_15( let __v_8: G = G::from_u64(255); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); - let __ret: [G; OUT_15] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + if 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); }, } @@ -2575,23 +2594,23 @@ fn aiur_fn_15( _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 - __v_8); - let __ret: [G; OUT_15] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_16] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + if 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_16: usize = 8; -const IN_16: usize = 8; -const OUT_16: usize = 1; -fn aiur_fn_16( - inp: [G; IN_16], +const INPUT_SIZE_17: usize = 8; +const IN_17: usize = 8; +const OUT_17: usize = 1; +fn aiur_fn_17( + inp: [G; IN_17], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_16], ExecError> { +) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2623,21 +2642,21 @@ fn aiur_fn_16( let __v_24: G = (__v_12 + __v_23); let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_0 + __v_25); - let __ret: [G; OUT_16] = [__v_26]; - if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_17] = [__v_26]; + if 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_17: usize = 4; -const IN_17: usize = 4; -const OUT_17: usize = 1; -fn aiur_fn_17( - inp: [G; IN_17], +const INPUT_SIZE_18: usize = 4; +const IN_18: usize = 4; +const OUT_18: usize = 1; +fn aiur_fn_18( + inp: [G; IN_18], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_17], ExecError> { +) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2652,21 +2671,21 @@ fn aiur_fn_17( let __v_10: G = (__v_7 + __v_9); let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_0 + __v_11); - let __ret: [G; OUT_17] = [__v_12]; - if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_18] = [__v_12]; + if 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_18: usize = 32; -const IN_18: usize = 32; -const OUT_18: usize = 8; -fn aiur_fn_18( - inp: [G; IN_18], +const INPUT_SIZE_19: usize = 32; +const IN_19: usize = 32; +const OUT_19: usize = 8; +fn aiur_fn_19( + inp: [G; IN_19], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_18], ExecError> { +) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2772,21 +2791,21 @@ fn aiur_fn_18( let __v_101: G = (__v_98 + __v_100); let __v_102: G = (__v_96 + __v_101); let __v_103: G = (__v_28 + __v_102); - let __ret: [G; OUT_18] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103]; - if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_19] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103]; + if 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_19: usize = 1; -const IN_19: usize = 1; -const OUT_19: usize = 32; -fn aiur_fn_19( - inp: [G; IN_19], +const INPUT_SIZE_20: usize = 1; +const IN_20: usize = 1; +const OUT_20: usize = 32; +fn aiur_fn_20( + inp: [G; IN_20], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_19], ExecError> { +) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); @@ -2839,9 +2858,9 @@ fn aiur_fn_19( let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; 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_51: G = __r_arr[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_51]; let __cu = unconstrained; 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_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -2874,21 +2893,21 @@ fn aiur_fn_19( let __v_81: G = __r_arr[29]; let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; - let __ret: [G; OUT_19] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; - if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_20] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; + if 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_20: usize = 33; -const IN_20: usize = 33; -const OUT_20: usize = 0; -fn aiur_fn_20( - inp: [G; IN_20], +const INPUT_SIZE_21: usize = 33; +const IN_21: usize = 33; +const OUT_21: usize = 0; +fn aiur_fn_21( + inp: [G; IN_21], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_20], ExecError> { +) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2973,9 +2992,9 @@ fn aiur_fn_20( let __v_80: G = G::from_u64(1); let __v_81: G = G::from_u64(1); let __v_82: G = { let __values: [G; 34] = [__v_80, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_67, __v_68, __v_69, __v_78, __v_79, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_67, __v_68, __v_69, __v_78, __v_79, __v_82]; let __cu = unconstrained; 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_83: G = __r_arr[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_83]; let __cu = unconstrained; 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_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; @@ -3104,21 +3123,21 @@ fn aiur_fn_20( if (__v_115 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } - let __ret: [G; OUT_20] = []; - if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_21] = []; + if 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_21: usize = 1; -const IN_21: usize = 1; -const OUT_21: usize = 1; -fn aiur_fn_21( - inp: [G; IN_21], +const INPUT_SIZE_22: usize = 1; +const IN_22: usize = 1; +const OUT_22: usize = 1; +fn aiur_fn_22( + inp: [G; IN_22], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_21], ExecError> { +) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); @@ -3171,9 +3190,9 @@ fn aiur_fn_21( let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; 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_51: G = __r_arr[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_51]; let __cu = unconstrained; 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_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -3207,21 +3226,21 @@ fn aiur_fn_21( let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; let __v_84: G = { let __values: [G; 32] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_21] = [__v_84]; - if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_22] = [__v_84]; + 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_22: usize = 34; -const IN_22: usize = 34; -const OUT_22: usize = 34; -fn aiur_fn_22( - inp: [G; IN_22], +const INPUT_SIZE_23: usize = 34; +const IN_23: usize = 34; +const OUT_23: usize = 34; +fn aiur_fn_23( + inp: [G; IN_23], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_22], ExecError> { +) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -3295,13 +3314,13 @@ fn aiur_fn_22( match __v_34.as_canonical_u64() { 1u64 => { let __v_68: G = G::from_u64(1); - let __ret: [G; OUT_22] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_23] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0]; + if 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); }, 0u64 => { let __v_68: G = G::from_u64(0); - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __v_70: G = __r_arr[1]; let __v_71: G = __r_arr[2]; @@ -3339,8 +3358,8 @@ fn aiur_fn_22( match __v_69.as_canonical_u64() { 0u64 => { let __v_103: G = G::from_u64(1); - let __ret: [G; OUT_22] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_23] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102]; + if 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); }, 1u64 => { @@ -3449,7 +3468,7 @@ fn aiur_fn_22( let __v_202: G = G::from_u64(0); let __v_203: G = G::from_u64(0); let __v_204: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; 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_205: G = __r_arr[0]; let __v_206: G = __r_arr[1]; let __v_207: G = __r_arr[2]; @@ -3486,8 +3505,8 @@ fn aiur_fn_22( let __v_238: G = G::from_u64(0); let __v_239: G = G::from_u64(0); let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_22] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_23] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240]; + if 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); }, _ => { @@ -3523,7 +3542,7 @@ fn aiur_fn_22( let __v_200: G = G::from_u64(0); let __v_201: G = G::from_u64(0); let __v_202: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; 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_203: G = __r_arr[0]; let __v_204: G = __r_arr[1]; let __v_205: G = __r_arr[2]; @@ -3560,8 +3579,8 @@ fn aiur_fn_22( let __v_236: G = G::from_u64(0); let __v_237: G = G::from_u64(0); let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_22] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238]; - if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_23] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238]; + if 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); }, } @@ -3578,15 +3597,15 @@ fn aiur_fn_22( }) } -const INPUT_SIZE_23: usize = 1; -const IN_23: usize = 1; -const OUT_23: usize = 32; -fn aiur_fn_23( - inp: [G; IN_23], +const INPUT_SIZE_24: usize = 1; +const IN_24: usize = 1; +const OUT_24: usize = 32; +fn aiur_fn_24( + inp: [G; IN_24], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_23], ExecError> { +) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -3663,13 +3682,13 @@ fn aiur_fn_23( let __v_68: G = __loaded[33]; match __v_35.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_23] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; - if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_24] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; + if 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); }, _ => { let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; let __v_72: G = __r_arr[2]; @@ -3706,7 +3725,7 @@ fn aiur_fn_23( let __v_103: G = __r_arr[33]; match __v_70.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_103]; let __cu = unconstrained; 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_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = __r_arr[2]; @@ -3739,14 +3758,14 @@ fn aiur_fn_23( let __v_133: G = __r_arr[29]; let __v_134: G = __r_arr[30]; let __v_135: G = __r_arr[31]; - let __ret: [G; OUT_23] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; - if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_24] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; + if 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_104: G = G::from_u64(0); let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_105]; 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_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __r_arr[2]; @@ -3779,8 +3798,8 @@ fn aiur_fn_23( let __v_135: G = __r_arr[29]; let __v_136: G = __r_arr[30]; let __v_137: G = __r_arr[31]; - let __ret: [G; OUT_23] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; - if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_24] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; + if 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); }, _ => { @@ -3797,15 +3816,15 @@ fn aiur_fn_23( }) } -const INPUT_SIZE_24: usize = 7; -const IN_24: usize = 7; -const OUT_24: usize = 1; -fn aiur_fn_24( - inp: [G; IN_24], +const INPUT_SIZE_25: usize = 7; +const IN_25: usize = 7; +const OUT_25: usize = 1; +fn aiur_fn_25( + inp: [G; IN_25], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_24], ExecError> { +) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -3820,10 +3839,10 @@ fn aiur_fn_24( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_24] = [__v_10]; - if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_25] = [__v_10]; + if 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); }, 0u64 => { @@ -3831,10 +3850,10 @@ fn aiur_fn_24( 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_28] = { let __args: [G; IN_28] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; 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_12: G = __r_arr[0]; - let __ret: [G; OUT_24] = [__v_12]; - if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_25] = [__v_12]; + if 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); }, _ => { @@ -3842,10 +3861,10 @@ fn aiur_fn_24( let __v_13: G = (__v_2 + __v_12); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; 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_16: G = __r_arr[0]; - let __ret: [G; OUT_24] = [__v_16]; - if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_25] = [__v_16]; + if 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); }, } @@ -3857,15 +3876,15 @@ fn aiur_fn_24( }) } -const INPUT_SIZE_25: usize = 1; -const IN_25: usize = 1; -const OUT_25: usize = 64; -fn aiur_fn_25( - inp: [G; IN_25], +const INPUT_SIZE_26: usize = 1; +const IN_26: usize = 1; +const OUT_26: usize = 64; +fn aiur_fn_26( + inp: [G; IN_26], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_25], ExecError> { +) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -4252,8 +4271,8 @@ fn aiur_fn_25( let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_25] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; - if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_26] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; + if 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); }, _ => { @@ -4578,22 +4597,22 @@ fn aiur_fn_25( }) } -const INPUT_SIZE_26: usize = 2; -const IN_26: usize = 2; -const OUT_26: usize = 1; -fn aiur_fn_26( - inp: [G; IN_26], +const INPUT_SIZE_27: usize = 2; +const IN_27: usize = 2; +const OUT_27: usize = 1; +fn aiur_fn_27( + inp: [G; IN_27], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_26], ExecError> { +) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_26] = [__v_0]; - if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_27] = [__v_0]; + if 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); }, _ => { @@ -4602,25 +4621,25 @@ fn aiur_fn_26( 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_26] = { let __args: [G; IN_26] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_4, __v_6]; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_26] = [__v_7]; - if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_27] = [__v_7]; + if 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_27: usize = 6; -const IN_27: usize = 6; -const OUT_27: usize = 1; -fn aiur_fn_27( - inp: [G; IN_27], +const INPUT_SIZE_28: usize = 6; +const IN_28: usize = 6; +const OUT_28: usize = 1; +fn aiur_fn_28( + inp: [G; IN_28], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_27], ExecError> { +) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -4793,7 +4812,7 @@ fn aiur_fn_27( let __v_145: G = G::from_u64(0); let __v_146: G = G::from_u64(0); let __v_147: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; 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_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __v_150: G = __r_arr[2]; @@ -4827,62 +4846,62 @@ fn aiur_fn_27( let __v_178: G = __r_arr[30]; let __v_179: G = __r_arr[31]; let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_27] = [__v_180]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_180]; + 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); }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if 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); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if 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); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if 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); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if 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); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if 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); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if 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); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if 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); }, } }, _ => { - let __ret: [G; OUT_27] = [__v_5]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_5]; + if 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); }, } @@ -4923,8 +4942,8 @@ fn aiur_fn_27( let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_27] = [__v_42]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_42]; + 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); }, } @@ -4939,7 +4958,7 @@ fn aiur_fn_27( let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 * __v_8); let __v_19: G = (__v_2 - __v_1); @@ -4949,9 +4968,9 @@ fn aiur_fn_27( let __v_23: G = (__v_7 + __v_22); let __v_24: G = G::from_u64(64); let __v_25: G = (__v_24 - __v_1); - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0, __v_25]; let __cu = unconstrained; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_26]; let __cu = unconstrained; 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_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -5082,7 +5101,7 @@ fn aiur_fn_27( let __v_152: G = G::from_u64(0); let __v_153: G = G::from_u64(0); let __v_154: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; 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_155: G = __r_arr[0]; let __v_156: G = __r_arr[1]; let __v_157: G = __r_arr[2]; @@ -5116,23 +5135,23 @@ fn aiur_fn_27( let __v_185: G = __r_arr[30]; let __v_186: G = __r_arr[31]; let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_27] = [__v_187]; - if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_28] = [__v_187]; + 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_28: usize = 6; -const IN_28: usize = 6; -const OUT_28: usize = 1; -fn aiur_fn_28( - inp: [G; IN_28], +const INPUT_SIZE_29: usize = 6; +const IN_29: usize = 6; +const OUT_29: usize = 1; +fn aiur_fn_29( + inp: [G; IN_29], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_28], ExecError> { +) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -5143,7 +5162,7 @@ fn aiur_fn_28( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_1]; let __cu = unconstrained; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -5221,7 +5240,7 @@ fn aiur_fn_28( let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = (__v_73 * __v_82); let __v_84: G = (__v_8 * __v_83); @@ -5325,7 +5344,7 @@ fn aiur_fn_28( let __v_180: G = G::from_u64(0); let __v_181: G = G::from_u64(0); let __v_182: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; 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_183: G = __r_arr[0]; let __v_184: G = __r_arr[1]; let __v_185: G = __r_arr[2]; @@ -5373,7 +5392,7 @@ fn aiur_fn_28( let __v_226: G = __loaded[5]; let __v_227: G = __loaded[6]; let __v_228: G = __loaded[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_229: G = __r_arr[0]; let __v_230: G = __r_arr[1]; let __v_231: G = __r_arr[2]; @@ -5384,10 +5403,10 @@ fn aiur_fn_28( let __v_236: G = __r_arr[7]; let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; 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_239: G = __r_arr[0]; - let __ret: [G; OUT_28] = [__v_239]; - if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_29] = [__v_239]; + if 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); }, _ => { @@ -5405,7 +5424,7 @@ fn aiur_fn_28( let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = (__v_84 * __v_8); let __v_86: G = (__v_75 * __v_85); @@ -5481,7 +5500,7 @@ fn aiur_fn_28( let __v_154: G = G::from_u64(0); let __v_155: G = G::from_u64(0); let __v_156: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; 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_157: G = __r_arr[0]; let __v_158: G = __r_arr[1]; let __v_159: G = __r_arr[2]; @@ -5521,25 +5540,25 @@ fn aiur_fn_28( let __v_193: G = G::from_u64(1); let __v_194: G = (__v_2 + __v_193); let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; 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_196: G = __r_arr[0]; - let __ret: [G; OUT_28] = [__v_196]; - if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_29] = [__v_196]; + if 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_29: usize = 24; -const IN_29: usize = 24; -const OUT_29: usize = 16; -fn aiur_fn_29( - inp: [G; IN_29], +const INPUT_SIZE_30: usize = 24; +const IN_30: usize = 24; +const OUT_30: usize = 16; +fn aiur_fn_30( + inp: [G; IN_30], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_29], ExecError> { +) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -5669,21 +5688,21 @@ fn aiur_fn_29( let __v_89: G = (__v_82 + __v_85); let __v_90: G = (__v_84 + __v_87); let __v_91: G = (__v_86 + __v_81); - let __ret: [G; OUT_29] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70]; - if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_30] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70]; + if 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_30: usize = 128; -const IN_30: usize = 128; -const OUT_30: usize = 128; -fn aiur_fn_30( - inp: [G; IN_30], +const INPUT_SIZE_31: usize = 128; +const IN_31: usize = 128; +const OUT_31: usize = 128; +fn aiur_fn_31( + inp: [G; IN_31], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_30], ExecError> { +) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -6645,21 +6664,21 @@ fn aiur_fn_30( let __v_669: G = (__v_662 + __v_665); let __v_670: G = (__v_664 + __v_667); let __v_671: G = (__v_666 + __v_661); - let __ret: [G; OUT_30] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; - if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_31] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; + if 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_31: usize = 106; -const IN_31: usize = 106; -const OUT_31: usize = 32; -fn aiur_fn_31( - inp: [G; IN_31], +const INPUT_SIZE_32: usize = 106; +const IN_32: usize = 106; +const OUT_32: usize = 32; +fn aiur_fn_32( + inp: [G; IN_32], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_31], ExecError> { +) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -6790,7 +6809,7 @@ fn aiur_fn_31( let __v_126: G = G::from_u64(0); let __v_127: G = G::from_u64(0); let __v_128: G = G::from_u64(0); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; 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_129: G = __r_arr[0]; let __v_130: G = __r_arr[1]; let __v_131: G = __r_arr[2]; @@ -6823,21 +6842,21 @@ fn aiur_fn_31( let __v_158: G = __r_arr[29]; let __v_159: G = __r_arr[30]; let __v_160: G = __r_arr[31]; - let __ret: [G; OUT_31] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; - if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_32] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; + if 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_32: usize = 129; -const IN_32: usize = 129; -const OUT_32: usize = 32; -fn aiur_fn_32( - inp: [G; IN_32], +const INPUT_SIZE_33: usize = 129; +const IN_33: usize = 129; +const OUT_33: usize = 32; +fn aiur_fn_33( + inp: [G; IN_33], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_32], ExecError> { +) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -7002,8 +7021,8 @@ fn aiur_fn_32( let __v_158: G = if unconstrained { Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record) }; let __v_159: G = if unconstrained { Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record) }; let __v_160: G = if unconstrained { Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record) }; - let __ret: [G; OUT_32] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; - if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_33] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; + if 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); }, _ => { @@ -7841,7 +7860,7 @@ fn aiur_fn_32( let __v_672: G = (__v_667 + __v_662); let __v_673: G = G::from_u64(1); let __v_674: G = (__v_0 + __v_673); - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; 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_675: G = __r_arr[0]; let __v_676: G = __r_arr[1]; let __v_677: G = __r_arr[2]; @@ -7874,23 +7893,23 @@ fn aiur_fn_32( let __v_704: G = __r_arr[29]; let __v_705: G = __r_arr[30]; let __v_706: G = __r_arr[31]; - let __ret: [G; OUT_32] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706]; - if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_33] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706]; + if 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_33: usize = 19; -const IN_33: usize = 19; -const OUT_33: usize = 1; -fn aiur_fn_33( - inp: [G; IN_33], +const INPUT_SIZE_34: usize = 19; +const IN_34: usize = 19; +const OUT_34: usize = 1; +fn aiur_fn_34( + inp: [G; IN_34], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_33], ExecError> { +) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -7914,18 +7933,18 @@ fn aiur_fn_33( match __v_0.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; 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 __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_20]; + if 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); }, 1u64 => { let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; 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 __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_20]; + if 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); }, 2u64 => { @@ -7939,14 +7958,14 @@ fn aiur_fn_33( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_9, __v_18]; let __cu = unconstrained; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; 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_30: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_30]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_30]; + if 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); }, 3u64 => { @@ -7960,14 +7979,14 @@ fn aiur_fn_33( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(3); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_9, __v_18]; let __cu = unconstrained; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; 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_30: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_30]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_30]; + if 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); }, 4u64 => { @@ -7991,34 +8010,34 @@ fn aiur_fn_33( let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __v_37: G = G::from_u64(4); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained; 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_38: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; 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_39: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; 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_40: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_40]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_40]; + if 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); }, 5u64 => { let __v_19: G = G::from_u64(5); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; 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 __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_20]; + if 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); }, 6u64 => { let __v_19: G = G::from_u64(6); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; 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 __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_20]; + if 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); }, 7u64 => { - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; 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 __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8028,16 +8047,16 @@ fn aiur_fn_33( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(7); - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; 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_29: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_29]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_29]; + if 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); }, 8u64 => { - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8047,16 +8066,16 @@ fn aiur_fn_33( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(8); - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; 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_29: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_29]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_29]; + if 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); }, 9u64 => { - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8066,12 +8085,12 @@ fn aiur_fn_33( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(9); - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; 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_29: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_29]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_29]; + if 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); }, 10u64 => { @@ -8133,24 +8152,24 @@ fn aiur_fn_33( let __v_71: G = __loaded[16]; let __v_72: G = __loaded[17]; let __v_73: G = G::from_u64(10); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; 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_74: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained; 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_75: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained; 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_76: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; 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_77: G = __r_arr[0]; - let __ret: [G; OUT_33] = [__v_77]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_77]; + if 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); }, 11u64 => { let __v_19: G = G::from_u64(11); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; 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 __ret: [G; OUT_33] = [__v_20]; - if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_34] = [__v_20]; + if 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); }, _ => { @@ -8160,15 +8179,15 @@ fn aiur_fn_33( }) } -const INPUT_SIZE_34: usize = 10; -const IN_34: usize = 10; -const OUT_34: usize = 1; -fn aiur_fn_34( - inp: [G; IN_34], +const INPUT_SIZE_35: usize = 10; +const IN_35: usize = 10; +const OUT_35: usize = 1; +fn aiur_fn_35( + inp: [G; IN_35], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_34], ExecError> { +) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8182,8 +8201,8 @@ fn aiur_fn_34( let __v_9: G = inp[9]; match __v_8.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_34] = [__v_9]; - if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_35] = [__v_9]; + if 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); }, _ => { @@ -8191,26 +8210,26 @@ fn aiur_fn_34( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_8 - __v_12); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; 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_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_34] = [__v_15]; - if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_35] = [__v_15]; + 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_35: usize = 9; -const IN_35: usize = 9; -const OUT_35: usize = 1; -fn aiur_fn_35( - inp: [G; IN_35], +const INPUT_SIZE_36: usize = 9; +const IN_36: usize = 9; +const OUT_36: usize = 1; +fn aiur_fn_36( + inp: [G; IN_36], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_35], ExecError> { +) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8221,7 +8240,7 @@ fn aiur_fn_35( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(128); let __v_11: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_10) } else { bytes2_less_than_value(__v_0, __v_10, record) }; @@ -8231,8 +8250,8 @@ fn aiur_fn_35( 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_35] = [__v_13]; - if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_36] = [__v_13]; + 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); }, _ => { @@ -8241,11 +8260,11 @@ fn aiur_fn_35( let __v_14: G = (__v_9 - __v_13); let __v_15: G = (__v_12 + __v_14); let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; 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_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_35] = [__v_18]; - if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_36] = [__v_18]; + 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); }, } @@ -8256,26 +8275,26 @@ fn aiur_fn_35( let __v_14: G = (__v_9 - __v_13); let __v_15: G = (__v_12 + __v_14); let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; 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_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_35] = [__v_18]; - if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_36] = [__v_18]; + 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_36: usize = 10; -const IN_36: usize = 10; -const OUT_36: usize = 1; -fn aiur_fn_36( - inp: [G; IN_36], +const INPUT_SIZE_37: usize = 10; +const IN_37: usize = 10; +const OUT_37: usize = 1; +fn aiur_fn_37( + inp: [G; IN_37], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_36], 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]; @@ -8287,7 +8306,7 @@ fn aiur_fn_36( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(32); let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) }; @@ -8300,8 +8319,8 @@ fn aiur_fn_36( let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_36] = [__v_17]; - if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_37] = [__v_17]; + if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -8313,11 +8332,11 @@ fn aiur_fn_36( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; 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_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_36] = [__v_22]; - if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_37] = [__v_22]; + if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -8331,26 +8350,26 @@ fn aiur_fn_36( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; 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_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_36] = [__v_22]; - if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_37] = [__v_22]; + if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_37: usize = 10; -const IN_37: usize = 10; -const OUT_37: usize = 1; -fn aiur_fn_37( - inp: [G; IN_37], +const INPUT_SIZE_38: usize = 10; +const IN_38: usize = 10; +const OUT_38: usize = 1; +fn aiur_fn_38( + inp: [G; IN_38], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_37], ExecError> { +) -> Result<[G; OUT_38], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8362,7 +8381,7 @@ fn aiur_fn_37( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) }; @@ -8375,8 +8394,8 @@ fn aiur_fn_37( let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_37] = [__v_17]; - if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_38] = [__v_17]; + 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); }, _ => { @@ -8388,11 +8407,11 @@ fn aiur_fn_37( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; 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_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_37] = [__v_22]; - if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_38] = [__v_22]; + 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); }, } @@ -8406,26 +8425,26 @@ fn aiur_fn_37( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; 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_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_37] = [__v_22]; - if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_38] = [__v_22]; + 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_38: usize = 2; -const IN_38: usize = 2; -const OUT_38: usize = 1; -fn aiur_fn_38( - inp: [G; IN_38], +const INPUT_SIZE_39: usize = 2; +const IN_39: usize = 2; +const OUT_39: usize = 1; +fn aiur_fn_39( + inp: [G; IN_39], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_38], 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]; @@ -8442,109 +8461,21 @@ fn aiur_fn_38( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_38] = [__v_1]; - if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_39] = [__v_1]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_11, __v_1]; let __cu = unconstrained; 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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; 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_13: G = __r_arr[0]; - let __ret: [G; OUT_38] = [__v_13]; - if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_39: usize = 18; -const IN_39: usize = 18; -const OUT_39: usize = 8; -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]; - 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]; - match __v_0.as_canonical_u64() { - 7u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; - let __v_18: G = __loaded[0]; - let __v_19: G = __loaded[1]; - let __v_20: G = __loaded[2]; - let __v_21: G = __loaded[3]; - let __v_22: G = __loaded[4]; - let __v_23: G = __loaded[5]; - let __v_24: G = __loaded[6]; - let __v_25: G = __loaded[7]; - let __v_26: G = __loaded[8]; - let __v_27: G = __loaded[9]; - let __v_28: G = __loaded[10]; - let __v_29: G = __loaded[11]; - let __v_30: G = __loaded[12]; - let __v_31: G = __loaded[13]; - let __v_32: G = __loaded[14]; - let __v_33: G = __loaded[15]; - let __v_34: G = __loaded[16]; - let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; - let __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_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; - let __v_44: G = __r_arr[0]; - let __v_45: G = __r_arr[1]; - let __v_46: G = __r_arr[2]; - let __v_47: G = __r_arr[3]; - let __v_48: G = __r_arr[4]; - let __v_49: G = __r_arr[5]; - let __v_50: G = __r_arr[6]; - let __v_51: G = __r_arr[7]; - let __ret: [G; OUT_39] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + let __ret: [G; OUT_39] = [__v_13]; 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 __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 __ret: [G; OUT_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) @@ -8579,8 +8510,8 @@ fn aiur_fn_40( let __v_16: G = inp[16]; let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { - 8u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + 7u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -8608,7 +8539,7 @@ fn aiur_fn_40( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -8667,7 +8598,7 @@ fn aiur_fn_41( let __v_16: G = inp[16]; let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { - 9u64 => { + 8u64 => { let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; @@ -8696,7 +8627,7 @@ fn aiur_fn_41( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -8726,15 +8657,103 @@ fn aiur_fn_41( }) } -const INPUT_SIZE_42: usize = 19; -const IN_42: usize = 19; -const OUT_42: usize = 1; +const INPUT_SIZE_42: usize = 18; +const IN_42: usize = 18; +const OUT_42: usize = 8; fn aiur_fn_42( inp: [G; IN_42], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_42], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = 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]; + match __v_0.as_canonical_u64() { + 9u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + let __v_28: G = __loaded[10]; + let __v_29: G = __loaded[11]; + let __v_30: G = __loaded[12]; + let __v_31: G = __loaded[13]; + let __v_32: G = __loaded[14]; + let __v_33: G = __loaded[15]; + let __v_34: G = __loaded[16]; + let __v_35: G = __loaded[17]; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; 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_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_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __v_47: G = __r_arr[3]; + let __v_48: G = __r_arr[4]; + let __v_49: G = __r_arr[5]; + let __v_50: G = __r_arr[6]; + let __v_51: G = __r_arr[7]; + let __ret: [G; OUT_42] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + 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); + }, + _ => { + 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 __ret: [G; OUT_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + 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 = 19; +const IN_43: usize = 19; +const OUT_43: usize = 1; +fn aiur_fn_43( + inp: [G; IN_43], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8795,34 +8814,34 @@ fn aiur_fn_42( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; 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_55: G = __r_arr[0]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; 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_56: G = __r_arr[0]; - let __ret: [G; OUT_42] = [__v_56]; - if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_43] = [__v_56]; + if 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_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __ret: [G; OUT_42] = [__v_19]; - if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_43] = [__v_19]; + if 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_43: usize = 19; -const IN_43: usize = 19; -const OUT_43: usize = 1; -fn aiur_fn_43( - inp: [G; IN_43], +const INPUT_SIZE_44: usize = 19; +const IN_44: usize = 19; +const OUT_44: usize = 1; +fn aiur_fn_44( + inp: [G; IN_44], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_43], ExecError> { +) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8883,34 +8902,34 @@ fn aiur_fn_43( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; 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_55: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; 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_56: G = __r_arr[0]; - let __ret: [G; OUT_43] = [__v_56]; - if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_44] = [__v_56]; + if 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); }, _ => { - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __ret: [G; OUT_43] = [__v_19]; - if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_44] = [__v_19]; + if 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_44: usize = 19; -const IN_44: usize = 19; -const OUT_44: usize = 1; -fn aiur_fn_44( - inp: [G; IN_44], +const INPUT_SIZE_45: usize = 19; +const IN_45: usize = 19; +const OUT_45: usize = 1; +fn aiur_fn_45( + inp: [G; IN_45], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_44], ExecError> { +) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8971,34 +8990,34 @@ fn aiur_fn_44( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; 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_55: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; 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_56: G = __r_arr[0]; - let __ret: [G; OUT_44] = [__v_56]; - if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_45] = [__v_56]; + if 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_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __ret: [G; OUT_44] = [__v_19]; - if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_45] = [__v_19]; + if 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_45: usize = 2; -const IN_45: usize = 2; -const OUT_45: usize = 1; -fn aiur_fn_45( - inp: [G; IN_45], +const INPUT_SIZE_46: usize = 2; +const IN_46: usize = 2; +const OUT_46: usize = 1; +fn aiur_fn_46( + inp: [G; IN_46], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_45], ExecError> { +) -> Result<[G; OUT_46], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9099,21 +9118,21 @@ fn aiur_fn_45( 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_45] = [__v_97]; - if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_46] = [__v_97]; + 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_46: usize = 2; -const IN_46: usize = 2; -const OUT_46: usize = 1; -fn aiur_fn_46( - inp: [G; IN_46], +const INPUT_SIZE_47: usize = 2; +const IN_47: usize = 2; +const OUT_47: usize = 1; +fn aiur_fn_47( + inp: [G; IN_47], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_46], ExecError> { +) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9122,20 +9141,20 @@ fn aiur_fn_46( match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if 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); }, 1u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if 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); }, 2u64 => { let __v_2: G = G::from_u64(2); - let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if 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); }, _ => { @@ -9147,20 +9166,20 @@ fn aiur_fn_46( match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(4); - let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if 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); }, 1u64 => { let __v_2: G = G::from_u64(5); - let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if 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); }, 2u64 => { let __v_2: G = G::from_u64(6); - let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if 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); }, _ => { @@ -9172,20 +9191,20 @@ fn aiur_fn_46( match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(8); - let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if 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); }, 1u64 => { let __v_2: G = G::from_u64(9); - let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if 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); }, 2u64 => { let __v_2: G = G::from_u64(10); - let __ret: [G; OUT_46] = [__v_2]; - if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_47] = [__v_2]; + if 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); }, _ => { @@ -9200,15 +9219,15 @@ fn aiur_fn_46( }) } -const INPUT_SIZE_47: usize = 9; -const IN_47: usize = 9; -const OUT_47: usize = 8; -fn aiur_fn_47( - inp: [G; IN_47], +const INPUT_SIZE_48: usize = 9; +const IN_48: usize = 9; +const OUT_48: usize = 8; +fn aiur_fn_48( + inp: [G; IN_48], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_47], ExecError> { +) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9231,7 +9250,7 @@ fn aiur_fn_47( let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9240,7 +9259,7 @@ fn aiur_fn_47( let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -9249,8 +9268,8 @@ fn aiur_fn_47( let __v_31: G = __r_arr[5]; let __v_32: G = __r_arr[6]; let __v_33: G = __r_arr[7]; - let __ret: [G; OUT_47] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_48] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + if 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); }, _ => { @@ -9262,23 +9281,23 @@ fn aiur_fn_47( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_47] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; - if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; + if 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_48: usize = 9; -const IN_48: usize = 9; -const OUT_48: usize = 9; -fn aiur_fn_48( - inp: [G; IN_48], +const INPUT_SIZE_49: usize = 9; +const IN_49: usize = 9; +const OUT_49: usize = 9; +fn aiur_fn_49( + inp: [G; IN_49], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_48], ExecError> { +) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9301,7 +9320,7 @@ fn aiur_fn_48( let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9311,28 +9330,28 @@ fn aiur_fn_48( let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; - let __ret: [G; OUT_48] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + if 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); }, _ => { - let __ret: [G; OUT_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if 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_49: usize = 10; -const IN_49: usize = 10; -const OUT_49: usize = 1; -fn aiur_fn_49( - inp: [G; IN_49], +const INPUT_SIZE_50: usize = 10; +const IN_50: usize = 10; +const OUT_50: usize = 1; +fn aiur_fn_50( + inp: [G; IN_50], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_49], ExecError> { +) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9349,12 +9368,12 @@ fn aiur_fn_49( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_49] = [__v_12]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_50] = [__v_12]; + 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); }, 1u64 => { - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -9363,7 +9382,7 @@ fn aiur_fn_49( let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9374,12 +9393,12 @@ fn aiur_fn_49( let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; 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_29: G = __r_arr[0]; - let __ret: [G; OUT_49] = [__v_29]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_50] = [__v_29]; + if 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); }, 2u64 => { @@ -9412,14 +9431,14 @@ fn aiur_fn_49( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; 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_37: G = __r_arr[0]; - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; 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_38: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; 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_39: G = __r_arr[0]; - let __ret: [G; OUT_49] = [__v_39]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_50] = [__v_39]; + if 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); }, 3u64 => { @@ -9452,22 +9471,22 @@ fn aiur_fn_49( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; 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_37: G = __r_arr[0]; - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; 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_38: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; 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_39: G = __r_arr[0]; - let __ret: [G; OUT_49] = [__v_39]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_50] = [__v_39]; + if 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); }, 4u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; 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_11: G = __r_arr[0]; - let __ret: [G; OUT_49] = [__v_11]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_50] = [__v_11]; + if 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); }, _ => { @@ -9477,15 +9496,15 @@ fn aiur_fn_49( }) } -const INPUT_SIZE_50: usize = 2; -const IN_50: usize = 2; -const OUT_50: usize = 1; -fn aiur_fn_50( - inp: [G; IN_50], +const INPUT_SIZE_51: usize = 2; +const IN_51: usize = 2; +const OUT_51: usize = 1; +fn aiur_fn_51( + inp: [G; IN_51], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_50], ExecError> { +) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9495,8 +9514,8 @@ fn aiur_fn_50( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_50] = [__v_1]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_51] = [__v_1]; + if 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); }, 0u64 => { @@ -9519,12 +9538,12 @@ fn aiur_fn_50( let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; 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_24: G = __r_arr[0]; - let __ret: [G; OUT_50] = [__v_24]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_51] = [__v_24]; + if 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); }, _ => { @@ -9534,15 +9553,15 @@ fn aiur_fn_50( }) } -const INPUT_SIZE_51: usize = 2; -const IN_51: usize = 2; -const OUT_51: usize = 1; -fn aiur_fn_51( - inp: [G; IN_51], +const INPUT_SIZE_52: usize = 2; +const IN_52: usize = 2; +const OUT_52: usize = 1; +fn aiur_fn_52( + inp: [G; IN_52], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_51], ExecError> { +) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9552,8 +9571,8 @@ fn aiur_fn_51( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_51] = [__v_1]; - if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_52] = [__v_1]; + if 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); }, 0u64 => { @@ -9567,12 +9586,12 @@ fn aiur_fn_51( let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_4, __v_1]; let __cu = unconstrained; 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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; 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_15: G = __r_arr[0]; - let __ret: [G; OUT_51] = [__v_15]; - if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_52] = [__v_15]; + if 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); }, _ => { @@ -9582,15 +9601,15 @@ fn aiur_fn_51( }) } -const INPUT_SIZE_52: usize = 2; -const IN_52: usize = 2; -const OUT_52: usize = 1; -fn aiur_fn_52( - inp: [G; IN_52], +const INPUT_SIZE_53: usize = 2; +const IN_53: usize = 2; +const OUT_53: usize = 1; +fn aiur_fn_53( + inp: [G; IN_53], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_52], ExecError> { +) -> Result<[G; OUT_53], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9600,17 +9619,17 @@ fn aiur_fn_52( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_52] = [__v_1]; - if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_53] = [__v_1]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_4, __v_1]; let __cu = unconstrained; 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 __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_52] = [__v_6]; - if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_53] = [__v_6]; + if 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); }, _ => { @@ -9620,15 +9639,15 @@ fn aiur_fn_52( }) } -const INPUT_SIZE_53: usize = 2; -const IN_53: usize = 2; -const OUT_53: usize = 1; -fn aiur_fn_53( - inp: [G; IN_53], +const INPUT_SIZE_54: usize = 2; +const IN_54: usize = 2; +const OUT_54: usize = 1; +fn aiur_fn_54( + inp: [G; IN_54], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_53], ExecError> { +) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9637,32 +9656,32 @@ fn aiur_fn_53( let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_53] = [__v_4]; - if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_54] = [__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); }, 1u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_53] = [__v_4]; - if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_54] = [__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); }, 2u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(2); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_53] = [__v_4]; - if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_54] = [__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); }, 3u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(3); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_53] = [__v_4]; - if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_54] = [__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); }, _ => { @@ -9672,15 +9691,15 @@ fn aiur_fn_53( }) } -const INPUT_SIZE_54: usize = 13; -const IN_54: usize = 13; -const OUT_54: usize = 1; -fn aiur_fn_54( - inp: [G; IN_54], +const INPUT_SIZE_55: usize = 13; +const IN_55: usize = 13; +const OUT_55: usize = 1; +fn aiur_fn_55( + inp: [G; IN_55], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_54], ExecError> { +) -> Result<[G; OUT_55], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9735,33 +9754,33 @@ fn aiur_fn_54( let __v_46: G = __loaded[15]; let __v_47: G = __loaded[16]; let __v_48: G = __loaded[17]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; 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_51: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; 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_52: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; 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_53: G = __r_arr[0]; let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_54] = [__v_54]; - if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_55] = [__v_54]; + 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_55: usize = 10; -const IN_55: usize = 10; -const OUT_55: usize = 1; -fn aiur_fn_55( - inp: [G; IN_55], +const INPUT_SIZE_56: usize = 10; +const IN_56: usize = 10; +const OUT_56: usize = 1; +fn aiur_fn_56( + inp: [G; IN_56], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_55], ExecError> { +) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9794,27 +9813,27 @@ fn aiur_fn_55( let __v_25: G = __loaded[15]; let __v_26: G = __loaded[16]; let __v_27: G = __loaded[17]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; 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_29: G = __r_arr[0]; - let __ret: [G; OUT_55] = [__v_29]; - if let Some(result) = record.function_queries[55].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_56] = [__v_29]; + if 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_56: usize = 2; -const IN_56: usize = 2; -const OUT_56: usize = 1; -fn aiur_fn_56( - inp: [G; IN_56], +const INPUT_SIZE_57: usize = 2; +const IN_57: usize = 2; +const OUT_57: usize = 1; +fn aiur_fn_57( + inp: [G; IN_57], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_56], ExecError> { +) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9832,17 +9851,17 @@ fn aiur_fn_56( let __v_12: G = __loaded[10]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_56] = [__v_1]; - if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_57] = [__v_1]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; 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 __v_14: G = __r_arr[0]; - let __ret: [G; OUT_56] = [__v_14]; - if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_57] = [__v_14]; + if 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); }, _ => { @@ -9852,15 +9871,15 @@ fn aiur_fn_56( }) } -const INPUT_SIZE_57: usize = 45; -const IN_57: usize = 45; -const OUT_57: usize = 1; -fn aiur_fn_57( - inp: [G; IN_57], +const INPUT_SIZE_58: usize = 45; +const IN_58: usize = 45; +const OUT_58: usize = 1; +fn aiur_fn_58( + inp: [G; IN_58], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_57], ExecError> { +) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9941,40 +9960,40 @@ fn aiur_fn_57( let __v_72: G = __r_arr[6]; let __v_73: G = __r_arr[7]; let __v_74: G = G::from_u64(0); - let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; 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_76: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; 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_77: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; 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_78: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; 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_79: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; 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_80: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; 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_81: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; 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_82: G = __r_arr[0]; let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_57] = [__v_83]; - if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_58] = [__v_83]; + 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_58: usize = 11; -const IN_58: usize = 11; -const OUT_58: usize = 1; -fn aiur_fn_58( - inp: [G; IN_58], +const INPUT_SIZE_59: usize = 11; +const IN_59: usize = 11; +const OUT_59: usize = 1; +fn aiur_fn_59( + inp: [G; IN_59], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_58], ExecError> { +) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10009,28 +10028,28 @@ fn aiur_fn_58( let __v_27: G = __loaded[16]; let __v_28: G = __loaded[17]; let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; 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_30: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; 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_31: G = __r_arr[0]; let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_58] = [__v_32]; - if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_59] = [__v_32]; + 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_59: usize = 11; -const IN_59: usize = 11; -const OUT_59: usize = 1; -fn aiur_fn_59( - inp: [G; IN_59], +const INPUT_SIZE_60: usize = 11; +const IN_60: usize = 11; +const OUT_60: usize = 1; +fn aiur_fn_60( + inp: [G; IN_60], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_59], ExecError> { +) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10064,29 +10083,29 @@ fn aiur_fn_59( let __v_26: G = __loaded[15]; let __v_27: G = __loaded[16]; let __v_28: G = __loaded[17]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; 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 __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_59] = [__v_31]; - if let Some(result) = record.function_queries[59].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_60] = [__v_31]; + if 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_60: usize = 35; -const IN_60: usize = 35; -const OUT_60: usize = 1; -fn aiur_fn_60( - inp: [G; IN_60], +const INPUT_SIZE_61: usize = 35; +const IN_61: usize = 35; +const OUT_61: usize = 1; +fn aiur_fn_61( + inp: [G; IN_61], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_60], ExecError> { +) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10145,34 +10164,34 @@ fn aiur_fn_60( let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; 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_54: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; 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_55: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; 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_56: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; 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_57: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; 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_58: G = __r_arr[0]; let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_60] = [__v_59]; - if let Some(result) = record.function_queries[60].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_61] = [__v_59]; + 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_61: usize = 2; -const IN_61: usize = 2; -const OUT_61: usize = 1; -fn aiur_fn_61( - inp: [G; IN_61], +const INPUT_SIZE_62: usize = 2; +const IN_62: usize = 2; +const OUT_62: usize = 1; +fn aiur_fn_62( + inp: [G; IN_62], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_61], ExecError> { +) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10215,17 +10234,17 @@ fn aiur_fn_61( let __v_37: G = __loaded[35]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_61] = [__v_1]; - if let Some(result) = record.function_queries[61].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_62] = [__v_1]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_60(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_61] = [__v_39]; - if let Some(result) = record.function_queries[61].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_62] = [__v_39]; + if 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); }, _ => { @@ -10235,15 +10254,15 @@ fn aiur_fn_61( }) } -const INPUT_SIZE_62: usize = 28; -const IN_62: usize = 28; -const OUT_62: usize = 1; -fn aiur_fn_62( - inp: [G; IN_62], +const INPUT_SIZE_63: usize = 28; +const IN_63: usize = 28; +const OUT_63: usize = 1; +fn aiur_fn_63( + inp: [G; IN_63], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_62], ExecError> { +) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10304,36 +10323,36 @@ fn aiur_fn_62( let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; 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_56: G = __r_arr[0]; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; 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_57: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; 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_58: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; 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_59: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; 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_60: G = __r_arr[0]; let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_62] = [__v_61]; - if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_63] = [__v_61]; + 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_63: usize = 10; -const IN_63: usize = 10; -const OUT_63: usize = 1; -fn aiur_fn_63( - inp: [G; IN_63], +const INPUT_SIZE_64: usize = 10; +const IN_64: usize = 10; +const OUT_64: usize = 1; +fn aiur_fn_64( + inp: [G; IN_64], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_63], ExecError> { +) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10347,27 +10366,27 @@ fn aiur_fn_63( let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_8, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; 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 __ret: [G; OUT_63] = [__v_11]; - if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_64] = [__v_11]; + if 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_64: usize = 18; -const IN_64: usize = 18; -const OUT_64: usize = 1; -fn aiur_fn_64( - inp: [G; IN_64], +const INPUT_SIZE_65: usize = 18; +const IN_65: usize = 18; +const OUT_65: usize = 1; +fn aiur_fn_65( + inp: [G; IN_65], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_64], ExecError> { +) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10389,29 +10408,29 @@ fn aiur_fn_64( let __v_17: G = inp[17]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_16, __v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; - let __ret: [G; OUT_64] = [__v_20]; - if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_65] = [__v_20]; + if 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_65: usize = 46; -const IN_65: usize = 46; -const OUT_65: usize = 1; -fn aiur_fn_65( - inp: [G; IN_65], +const INPUT_SIZE_66: usize = 46; +const IN_66: usize = 46; +const OUT_66: usize = 1; +fn aiur_fn_66( + inp: [G; IN_66], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_65], ExecError> { +) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10463,31 +10482,31 @@ fn aiur_fn_65( 0u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; 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_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_65] = [__v_49]; - if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_66] = [__v_49]; + 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_46: G = G::from_u64(0); let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } } else { aiur_fn_62(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; 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 __v_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_65] = [__v_49]; - if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_66] = [__v_49]; + 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); }, 2u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; 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_48: G = __r_arr[0]; let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_65] = [__v_49]; - if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_66] = [__v_49]; + 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); }, _ => { @@ -10497,15 +10516,15 @@ fn aiur_fn_65( }) } -const INPUT_SIZE_66: usize = 2; -const IN_66: usize = 2; -const OUT_66: usize = 1; -fn aiur_fn_66( - inp: [G; IN_66], +const INPUT_SIZE_67: usize = 2; +const IN_67: usize = 2; +const OUT_67: usize = 1; +fn aiur_fn_67( + inp: [G; IN_67], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_66], ExecError> { +) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10559,17 +10578,17 @@ fn aiur_fn_66( let __v_48: G = __loaded[46]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_66] = [__v_1]; - if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_67] = [__v_1]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_48, __v_1]; let __cu = unconstrained; 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_49: G = __r_arr[0]; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; 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_50: G = __r_arr[0]; - let __ret: [G; OUT_66] = [__v_50]; - if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_67] = [__v_50]; + if 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); }, _ => { @@ -10579,15 +10598,15 @@ fn aiur_fn_66( }) } -const INPUT_SIZE_67: usize = 46; -const IN_67: usize = 46; -const OUT_67: usize = 1; -fn aiur_fn_67( - inp: [G; IN_67], +const INPUT_SIZE_68: usize = 46; +const IN_68: usize = 46; +const OUT_68: usize = 1; +fn aiur_fn_68( + inp: [G; IN_68], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_67], ExecError> { +) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10637,59 +10656,59 @@ fn aiur_fn_67( let __v_45: G = inp[45]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; 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_46: G = __r_arr[0]; - let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_68] = [__v_46]; + if 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); }, 1u64 => { - let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } } else { aiur_fn_57(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; 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_46: G = __r_arr[0]; - let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_68] = [__v_46]; + if 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); }, 2u64 => { - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } } else { aiur_fn_59(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_68] = [__v_46]; + if 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); }, 3u64 => { - let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } } else { aiur_fn_59(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; 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_46: G = __r_arr[0]; - let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_68] = [__v_46]; + if 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); }, 4u64 => { - let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained; 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_46: G = __r_arr[0]; - let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_68] = [__v_46]; + if 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); }, 5u64 => { - let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; 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_46: G = __r_arr[0]; - let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_68] = [__v_46]; + if 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); }, 6u64 => { - let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; 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_46: G = __r_arr[0]; - let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_68] = [__v_46]; + if 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); }, 7u64 => { - let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; 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_46: G = __r_arr[0]; - let __ret: [G; OUT_67] = [__v_46]; - if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_68] = [__v_46]; + if 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); }, _ => { @@ -10699,15 +10718,15 @@ fn aiur_fn_67( }) } -const INPUT_SIZE_68: usize = 2; -const IN_68: usize = 2; -const OUT_68: usize = 1; -fn aiur_fn_68( - inp: [G; IN_68], +const INPUT_SIZE_69: usize = 2; +const IN_69: usize = 2; +const OUT_69: usize = 1; +fn aiur_fn_69( + inp: [G; IN_69], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_68], ExecError> { +) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10720,25 +10739,25 @@ fn aiur_fn_68( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; 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 __ret: [G; OUT_68] = [__v_11]; - if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_69] = [__v_11]; + if 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); }) } -const INPUT_SIZE_69: usize = 2; -const IN_69: usize = 2; -const OUT_69: usize = 1; -fn aiur_fn_69( - inp: [G; IN_69], +const INPUT_SIZE_70: usize = 2; +const IN_70: usize = 2; +const OUT_70: usize = 1; +fn aiur_fn_70( + inp: [G; IN_70], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_69], ExecError> { +) -> Result<[G; OUT_70], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10751,25 +10770,25 @@ fn aiur_fn_69( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_1]; let __cu = unconstrained; 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 __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; 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 __ret: [G; OUT_69] = [__v_11]; - if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_70] = [__v_11]; + if 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_70: usize = 2; -const IN_70: usize = 2; -const OUT_70: usize = 1; -fn aiur_fn_70( - inp: [G; IN_70], +const INPUT_SIZE_71: usize = 2; +const IN_71: usize = 2; +const OUT_71: usize = 1; +fn aiur_fn_71( + inp: [G; IN_71], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_70], ExecError> { +) -> Result<[G; OUT_71], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10782,25 +10801,25 @@ fn aiur_fn_70( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_1]; let __cu = unconstrained; 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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; 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 __ret: [G; OUT_70] = [__v_11]; - if let Some(result) = record.function_queries[70].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_71] = [__v_11]; + if 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_71: usize = 49; -const IN_71: usize = 49; -const OUT_71: usize = 1; -fn aiur_fn_71( - inp: [G; IN_71], +const INPUT_SIZE_72: usize = 49; +const IN_72: usize = 49; +const OUT_72: usize = 1; +fn aiur_fn_72( + inp: [G; IN_72], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_71], ExecError> { +) -> Result<[G; OUT_72], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10853,11 +10872,11 @@ fn aiur_fn_71( let __v_48: G = inp[48]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_70(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_47, __v_48]; let __cu = unconstrained; 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_49: G = __r_arr[0]; - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_46, __v_49]; let __cu = unconstrained; 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_50: G = __r_arr[0]; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_45, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_45, __v_50]; let __cu = unconstrained; 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_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { @@ -10871,12 +10890,12 @@ fn aiur_fn_71( let __v_58: G = __r_arr[6]; let __v_59: G = __r_arr[7]; let __v_60: G = G::from_u64(12); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_1, __v_51]; let __cu = unconstrained; 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_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; 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_62: G = __r_arr[0]; - let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_72] = [__v_62]; + if 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); }, 0u64 => { @@ -10889,12 +10908,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; 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_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; 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_62: G = __r_arr[0]; - let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_72] = [__v_62]; + if 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); }, 1u64 => { @@ -10907,12 +10926,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; 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_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; 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_62: G = __r_arr[0]; - let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_72] = [__v_62]; + if 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); }, 2u64 => { @@ -10925,12 +10944,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; 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_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; 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_62: G = __r_arr[0]; - let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_72] = [__v_62]; + if 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); }, 3u64 => { @@ -10943,12 +10962,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; 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_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; 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_62: G = __r_arr[0]; - let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_72] = [__v_62]; + if 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); }, 4u64 => { @@ -10961,12 +10980,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; 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_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; 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_62: G = __r_arr[0]; - let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_72] = [__v_62]; + if 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); }, 5u64 => { @@ -10979,12 +10998,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; 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_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; 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_62: G = __r_arr[0]; - let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_72] = [__v_62]; + if 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); }, 6u64 => { @@ -10997,12 +11016,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; 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_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; 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_62: G = __r_arr[0]; - let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_72] = [__v_62]; + if 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); }, 7u64 => { @@ -11015,12 +11034,12 @@ fn aiur_fn_71( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; 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_61: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; 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_62: G = __r_arr[0]; - let __ret: [G; OUT_71] = [__v_62]; - if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_72] = [__v_62]; + if 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); }, _ => { @@ -11032,15 +11051,15 @@ fn aiur_fn_71( }) } -const INPUT_SIZE_72: usize = 1; -const IN_72: usize = 1; -const OUT_72: usize = 2; -fn aiur_fn_72( - inp: [G; IN_72], +const INPUT_SIZE_73: usize = 1; +const IN_73: usize = 1; +const OUT_73: usize = 2; +fn aiur_fn_73( + inp: [G; IN_73], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_72], ExecError> { +) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -11049,8 +11068,8 @@ fn aiur_fn_72( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_72] = [__v_2, __v_3]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_73] = [__v_2, __v_3]; + if 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); }, 1u64 => { @@ -11058,8 +11077,8 @@ fn aiur_fn_72( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_72] = [__v_4, __v_7]; - if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_73] = [__v_4, __v_7]; + 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); }, _ => { @@ -11069,15 +11088,15 @@ fn aiur_fn_72( }) } -const INPUT_SIZE_73: usize = 2; -const IN_73: usize = 2; -const OUT_73: usize = 9; -fn aiur_fn_73( - inp: [G; IN_73], +const INPUT_SIZE_74: usize = 2; +const IN_74: usize = 2; +const OUT_74: usize = 9; +fn aiur_fn_74( + inp: [G; IN_74], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_73], ExecError> { +) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11091,8 +11110,8 @@ fn aiur_fn_73( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_73] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0]; - if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_74] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0]; + if 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); }, _ => { @@ -11104,7 +11123,7 @@ fn aiur_fn_73( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -11114,8 +11133,8 @@ fn aiur_fn_73( let __v_13: G = __r_arr[6]; let __v_14: G = __r_arr[7]; let __v_15: G = __r_arr[8]; - let __ret: [G; OUT_73] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15]; - if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_74] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15]; + if 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); }, _ => { @@ -11127,15 +11146,15 @@ fn aiur_fn_73( }) } -const INPUT_SIZE_74: usize = 1; -const IN_74: usize = 1; -const OUT_74: usize = 9; -fn aiur_fn_74( - inp: [G; IN_74], +const INPUT_SIZE_75: usize = 1; +const IN_75: usize = 1; +const OUT_75: usize = 9; +fn aiur_fn_75( + inp: [G; IN_75], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_74], ExecError> { +) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -11180,8 +11199,8 @@ fn aiur_fn_74( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_74] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3]; - if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_75] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3]; + if 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); }, _ => { @@ -11193,7 +11212,7 @@ fn aiur_fn_74( if (__v_33 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("tag0: payload width exceeds 8 bytes".to_string()) }); } - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; @@ -11203,8 +11222,8 @@ fn aiur_fn_74( let __v_41: G = __r_arr[6]; let __v_42: G = __r_arr[7]; let __v_43: G = __r_arr[8]; - let __ret: [G; OUT_74] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; - if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_75] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; + if 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); }, } @@ -11216,15 +11235,15 @@ fn aiur_fn_74( }) } -const INPUT_SIZE_75: usize = 1; -const IN_75: usize = 1; -const OUT_75: usize = 10; -fn aiur_fn_75( - inp: [G; IN_75], +const INPUT_SIZE_76: usize = 1; +const IN_76: usize = 1; +const OUT_76: usize = 10; +fn aiur_fn_76( + inp: [G; IN_76], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_75], ExecError> { +) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -11266,14 +11285,14 @@ fn aiur_fn_75( let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __ret: [G; OUT_75] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; - if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_76] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; + if 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 __v_27: G = G::from_u64(1); let __v_28: G = (__v_26 + __v_27); - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -11289,8 +11308,8 @@ fn aiur_fn_75( if (__v_39 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: Some("tag2: payload width exceeds 8 bytes".to_string()) }); } - let __ret: [G; OUT_75] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; - if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_76] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; + if 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); }, } @@ -11302,15 +11321,15 @@ fn aiur_fn_75( }) } -const INPUT_SIZE_76: usize = 1; -const IN_76: usize = 1; -const OUT_76: usize = 10; -fn aiur_fn_76( - inp: [G; IN_76], +const INPUT_SIZE_77: usize = 1; +const IN_77: usize = 1; +const OUT_77: usize = 10; +fn aiur_fn_77( + inp: [G; IN_77], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_76], ExecError> { +) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -11352,14 +11371,14 @@ fn aiur_fn_76( let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __ret: [G; OUT_76] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; - if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_77] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; + if 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); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_26 + __v_27); - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -11369,8 +11388,8 @@ fn aiur_fn_76( let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; - let __ret: [G; OUT_76] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; - if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_77] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; + if 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); }, } @@ -11382,15 +11401,15 @@ fn aiur_fn_76( }) } -const INPUT_SIZE_77: usize = 9; -const IN_77: usize = 9; -const OUT_77: usize = 2; -fn aiur_fn_77( - inp: [G; IN_77], +const INPUT_SIZE_78: usize = 9; +const IN_78: usize = 9; +const OUT_78: usize = 2; +fn aiur_fn_78( + inp: [G; IN_78], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_77], ExecError> { +) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11401,19 +11420,19 @@ fn aiur_fn_77( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_77] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_78] = [__v_12, __v_0]; + 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); }, 0u64 => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; 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 __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -11423,7 +11442,7 @@ fn aiur_fn_77( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -11432,13 +11451,13 @@ fn aiur_fn_77( let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; 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_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_77] = [__v_30, __v_28]; - if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_78] = [__v_30, __v_28]; + 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); }, _ => { @@ -11448,15 +11467,15 @@ fn aiur_fn_77( }) } -const INPUT_SIZE_78: usize = 10; -const IN_78: usize = 10; -const OUT_78: usize = 2; -fn aiur_fn_78( - inp: [G; IN_78], +const INPUT_SIZE_79: usize = 10; +const IN_79: usize = 10; +const OUT_79: usize = 2; +fn aiur_fn_79( + inp: [G; IN_79], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_78], ExecError> { +) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11468,22 +11487,22 @@ fn aiur_fn_78( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_78] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_79] = [__v_0, __v_1]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_1]; let __cu = unconstrained; 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 = G::from_u64(7); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -11492,11 +11511,11 @@ fn aiur_fn_78( let __v_21: G = __r_arr[5]; let __v_22: G = __r_arr[6]; let __v_23: G = __r_arr[7]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; 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_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __ret: [G; OUT_78] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_79] = [__v_24, __v_25]; + if 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); }, _ => { @@ -11506,15 +11525,15 @@ fn aiur_fn_78( }) } -const INPUT_SIZE_79: usize = 9; -const IN_79: usize = 9; -const OUT_79: usize = 2; -fn aiur_fn_79( - inp: [G; IN_79], +const INPUT_SIZE_80: usize = 9; +const IN_80: usize = 9; +const OUT_80: usize = 2; +fn aiur_fn_80( + inp: [G; IN_80], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_79], ExecError> { +) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11525,22 +11544,22 @@ fn aiur_fn_79( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; 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 __ret: [G; OUT_79] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_80] = [__v_10, __v_11]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; 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 __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -11549,14 +11568,14 @@ fn aiur_fn_79( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(8); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_79] = [__v_24, __v_21]; - if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_80] = [__v_24, __v_21]; + if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11566,15 +11585,15 @@ fn aiur_fn_79( }) } -const INPUT_SIZE_80: usize = 9; -const IN_80: usize = 9; -const OUT_80: usize = 2; -fn aiur_fn_80( - inp: [G; IN_80], +const INPUT_SIZE_81: usize = 9; +const IN_81: usize = 9; +const OUT_81: usize = 2; +fn aiur_fn_81( + inp: [G; IN_81], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_80], ExecError> { +) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11585,22 +11604,22 @@ fn aiur_fn_80( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; 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 __ret: [G; OUT_80] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_81] = [__v_10, __v_11]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; 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 __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -11609,14 +11628,14 @@ fn aiur_fn_80( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(9); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_80] = [__v_24, __v_21]; - if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_81] = [__v_24, __v_21]; + if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11626,18 +11645,18 @@ fn aiur_fn_80( }) } -const INPUT_SIZE_81: usize = 1; -const IN_81: usize = 1; -const OUT_81: usize = 2; -fn aiur_fn_81( - inp: [G; IN_81], +const INPUT_SIZE_82: usize = 1; +const IN_82: usize = 1; +const OUT_82: usize = 2; +fn aiur_fn_82( + inp: [G; IN_82], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_81], ExecError> { +) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; 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 __v_3: G = __r_arr[2]; @@ -11653,20 +11672,20 @@ fn aiur_fn_81( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_81] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_10]; + 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); }, 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_81] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_10]; + 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); }, 2u64 => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; let __cu = unconstrained; 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 __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11676,18 +11695,18 @@ fn aiur_fn_81( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_81] = [__v_24, __v_21]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_24, __v_21]; + 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); }, 3u64 => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; let __cu = unconstrained; 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 __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11697,18 +11716,18 @@ fn aiur_fn_81( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(3); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_81] = [__v_24, __v_21]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_24, __v_21]; + 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); }, 4u64 => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; let __cu = unconstrained; 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 __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11718,90 +11737,90 @@ fn aiur_fn_81( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_19]; let __cu = unconstrained; 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 = G::from_u64(4); let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_81] = [__v_23, __v_21]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_23, __v_21]; + 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); }, 5u64 => { let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_81] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_10]; + 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); }, 6u64 => { let __v_11: G = G::from_u64(6); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_81] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_10]; + 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); }, 7u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __cu = unconstrained; 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 __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("App with zero arguments".to_string()) }); } - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_81] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_15, __v_16]; + if 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); }, 8u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("Lam with zero binders".to_string()) }); } - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_81] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_14]; + if 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); }, 9u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("All with zero binders".to_string()) }); } - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_81] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_14]; + if 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); }, 10u64 => { - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_81] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_11, __v_12]; + if 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); }, 11u64 => { let __v_11: G = G::from_u64(11); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_81] = [__v_13, __v_10]; - if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_82] = [__v_13, __v_10]; + 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); }, _ => { @@ -11811,15 +11830,15 @@ fn aiur_fn_81( }) } -const INPUT_SIZE_82: usize = 9; -const IN_82: usize = 9; -const OUT_82: usize = 2; -fn aiur_fn_82( - inp: [G; IN_82], +const INPUT_SIZE_83: usize = 9; +const IN_83: usize = 9; +const OUT_83: usize = 2; +fn aiur_fn_83( + inp: [G; IN_83], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_82], ExecError> { +) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11830,33 +11849,33 @@ fn aiur_fn_82( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __cu = unconstrained; 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 __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_12]; let __cu = unconstrained; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(10); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 18] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_82] = [__v_17, __v_14]; - if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_83] = [__v_17, __v_14]; + 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_83: usize = 17; -const IN_83: usize = 17; -const OUT_83: usize = 9; -fn aiur_fn_83( - inp: [G; IN_83], +const INPUT_SIZE_84: usize = 17; +const IN_84: usize = 17; +const OUT_84: usize = 9; +fn aiur_fn_84( + inp: [G; IN_84], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_83], ExecError> { +) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11875,16 +11894,16 @@ fn aiur_fn_83( let __v_14: G = inp[14]; let __v_15: G = inp[15]; let __v_16: G = inp[16]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_83] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_84] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -11893,7 +11912,7 @@ fn aiur_fn_83( let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; 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_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -11906,8 +11925,8 @@ fn aiur_fn_83( let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_83] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; - if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_84] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; + if 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); }, _ => { @@ -11917,18 +11936,18 @@ fn aiur_fn_83( }) } -const INPUT_SIZE_84: usize = 1; -const IN_84: usize = 1; -const OUT_84: usize = 10; -fn aiur_fn_84( - inp: [G; IN_84], +const INPUT_SIZE_85: usize = 1; +const IN_85: usize = 1; +const OUT_85: usize = 10; +fn aiur_fn_85( + inp: [G; IN_85], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_84], ExecError> { +) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; 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_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -11941,18 +11960,18 @@ fn aiur_fn_84( let __v_10: G = __r_arr[9]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_84] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_85] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -11963,7 +11982,7 @@ fn aiur_fn_84( let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; 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_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; @@ -11973,8 +11992,8 @@ fn aiur_fn_84( let __v_28: G = __r_arr[6]; let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; - let __ret: [G; OUT_84] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_85] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; + if 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); }, _ => { @@ -11983,7 +12002,7 @@ fn aiur_fn_84( } }, 1u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -11994,7 +12013,7 @@ fn aiur_fn_84( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_20]; let __cu = unconstrained; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -12009,12 +12028,12 @@ fn aiur_fn_84( let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(0); - let __ret: [G; OUT_84] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_85] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; + if 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); }, 2u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12025,7 +12044,7 @@ fn aiur_fn_84( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_20]; let __cu = unconstrained; 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -12040,14 +12059,14 @@ fn aiur_fn_84( let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(0); - let __ret: [G; OUT_84] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_85] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; + if 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); }, 3u64 => { let __v_11: G = G::from_u64(4); - let __ret: [G; OUT_84] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_85] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + if 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); }, _ => { @@ -12057,15 +12076,15 @@ fn aiur_fn_84( }) } -const INPUT_SIZE_85: usize = 1; -const IN_85: usize = 1; -const OUT_85: usize = 2; -fn aiur_fn_85( - inp: [G; IN_85], +const INPUT_SIZE_86: usize = 1; +const IN_86: usize = 1; +const OUT_86: usize = 2; +fn aiur_fn_86( + inp: [G; IN_86], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_85], ExecError> { +) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -12261,8 +12280,8 @@ fn aiur_fn_85( match __v_94.as_canonical_u64() { 0u64 => { let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_85] = [__v_97, __v_96]; - if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_86] = [__v_97, __v_96]; + 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); }, _ => { @@ -12427,15 +12446,15 @@ fn aiur_fn_85( }) } -const INPUT_SIZE_86: usize = 9; -const IN_86: usize = 9; -const OUT_86: usize = 2; -fn aiur_fn_86( - inp: [G; IN_86], +const INPUT_SIZE_87: usize = 9; +const IN_87: usize = 9; +const OUT_87: usize = 2; +fn aiur_fn_87( + inp: [G; IN_87], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_86], ExecError> { +) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12446,22 +12465,22 @@ fn aiur_fn_86( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_86] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_87] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; 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 __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -12470,13 +12489,13 @@ fn aiur_fn_86( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_86] = [__v_23, __v_21]; - if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_87] = [__v_23, __v_21]; + 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); }, _ => { @@ -12486,15 +12505,15 @@ fn aiur_fn_86( }) } -const INPUT_SIZE_87: usize = 9; -const IN_87: usize = 9; -const OUT_87: usize = 2; -fn aiur_fn_87( - inp: [G; IN_87], +const INPUT_SIZE_88: usize = 9; +const IN_88: usize = 9; +const OUT_88: usize = 2; +fn aiur_fn_88( + inp: [G; IN_88], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_87], ExecError> { +) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12505,19 +12524,19 @@ fn aiur_fn_87( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_87] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_88] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -12528,7 +12547,7 @@ fn aiur_fn_87( let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = __r_arr[9]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -12537,14 +12556,14 @@ fn aiur_fn_87( let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = G::from_u64(0); let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_87] = [__v_32, __v_29]; - if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_88] = [__v_32, __v_29]; + 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); }, _ => { @@ -12554,15 +12573,15 @@ fn aiur_fn_87( }) } -const INPUT_SIZE_88: usize = 9; -const IN_88: usize = 9; -const OUT_88: usize = 2; -fn aiur_fn_88( - inp: [G; IN_88], +const INPUT_SIZE_89: usize = 9; +const IN_89: usize = 9; +const OUT_89: usize = 2; +fn aiur_fn_89( + inp: [G; IN_89], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_88], ExecError> { +) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12573,22 +12592,22 @@ fn aiur_fn_88( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_88] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_89] = [__v_12, __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); }, 0u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; 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 __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -12597,13 +12616,13 @@ fn aiur_fn_88( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_88] = [__v_23, __v_21]; - if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_89] = [__v_23, __v_21]; + 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); }, _ => { @@ -12613,36 +12632,6 @@ fn aiur_fn_88( }) } -const INPUT_SIZE_89: usize = 1; -const IN_89: usize = 1; -const OUT_89: usize = 2; -fn aiur_fn_89( - inp: [G; IN_89], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_89], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; - let __v_1: G = __r_arr[0]; - let __v_2: G = __r_arr[1]; - let __v_3: G = __r_arr[2]; - let __v_4: G = __r_arr[3]; - let __v_5: G = __r_arr[4]; - let __v_6: G = __r_arr[5]; - let __v_7: G = __r_arr[6]; - let __v_8: G = __r_arr[7]; - let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_89] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - const INPUT_SIZE_90: usize = 1; const IN_90: usize = 1; const OUT_90: usize = 2; @@ -12654,7 +12643,7 @@ fn aiur_fn_90( ) -> Result<[G; OUT_90], 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_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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12664,7 +12653,7 @@ fn aiur_fn_90( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_90] = [__v_10, __v_11]; @@ -12684,7 +12673,7 @@ fn aiur_fn_91( ) -> Result<[G; OUT_91], 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_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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12694,7 +12683,7 @@ fn aiur_fn_91( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_91] = [__v_10, __v_11]; @@ -12712,70 +12701,100 @@ fn aiur_fn_92( 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 __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 __v_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = __r_arr[4]; + let __v_6: G = __r_arr[5]; + let __v_7: G = __r_arr[6]; + let __v_8: G = __r_arr[7]; + let __v_9: G = __r_arr[8]; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_92] = [__v_10, __v_11]; + 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 = 1; +const IN_93: usize = 1; +const OUT_93: usize = 2; +fn aiur_fn_93( + inp: [G; IN_93], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if 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); }, 1u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if 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); }, 2u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(2); - let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if 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); }, 4u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if 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); }, 5u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if 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); }, 6u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(2); - let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if 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); }, 8u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if 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); }, 9u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if 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); }, 10u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(2); - let __ret: [G; OUT_92] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_93] = [__v_1, __v_2]; + if 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); }, _ => { @@ -12785,24 +12804,24 @@ fn aiur_fn_92( }) } -const INPUT_SIZE_93: usize = 1; -const IN_93: usize = 1; -const OUT_93: usize = 13; -fn aiur_fn_93( - inp: [G; IN_93], +const INPUT_SIZE_94: usize = 1; +const IN_94: usize = 1; +const OUT_94: usize = 13; +fn aiur_fn_94( + inp: [G; IN_94], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_93], ExecError> { +) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_1]; let __cu = unconstrained; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; 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 __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -12812,30 +12831,30 @@ fn aiur_fn_93( let __v_11: G = __r_arr[6]; let __v_12: G = __r_arr[7]; let __v_13: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_15]; let __cu = unconstrained; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_93] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17]; - if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_94] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17]; + if 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_94: usize = 1; -const IN_94: usize = 1; -const OUT_94: usize = 10; -fn aiur_fn_94( - inp: [G; IN_94], +const INPUT_SIZE_95: usize = 1; +const IN_95: usize = 1; +const OUT_95: usize = 10; +fn aiur_fn_95( + inp: [G; IN_95], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_94], ExecError> { +) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -12845,24 +12864,24 @@ fn aiur_fn_94( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_9]; let __cu = unconstrained; 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 __ret: [G; OUT_94] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; - if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_95] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; + if 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_95: usize = 9; -const IN_95: usize = 9; -const OUT_95: usize = 2; -fn aiur_fn_95( - inp: [G; IN_95], +const INPUT_SIZE_96: usize = 9; +const IN_96: usize = 9; +const OUT_96: usize = 2; +fn aiur_fn_96( + inp: [G; IN_96], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_95], ExecError> { +) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12873,19 +12892,19 @@ fn aiur_fn_95( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_95] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_12, __v_0]; + 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); }, 0u64 => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; 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 __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -12895,10 +12914,10 @@ fn aiur_fn_95( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_18]; let __cu = unconstrained; 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 __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -12907,13 +12926,13 @@ fn aiur_fn_95( let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 11] = [__v_31, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_29]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_95] = [__v_32, __v_30]; - if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_96] = [__v_32, __v_30]; + 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); }, _ => { @@ -12923,18 +12942,18 @@ fn aiur_fn_95( }) } -const INPUT_SIZE_96: usize = 1; -const IN_96: usize = 1; -const OUT_96: usize = 45; -fn aiur_fn_96( - inp: [G; IN_96], +const INPUT_SIZE_97: usize = 1; +const IN_97: usize = 1; +const OUT_97: usize = 45; +fn aiur_fn_97( + inp: [G; IN_97], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_96], ExecError> { +) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; @@ -12946,7 +12965,7 @@ fn aiur_fn_96( let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; 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 __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12956,7 +12975,7 @@ fn aiur_fn_96( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_19]; let __cu = unconstrained; 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 __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -12966,7 +12985,7 @@ fn aiur_fn_96( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_28]; let __cu = unconstrained; 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 __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -12976,7 +12995,7 @@ fn aiur_fn_96( let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_37]; let __cu = unconstrained; 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 __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -12986,7 +13005,7 @@ fn aiur_fn_96( let __v_44: G = __r_arr[6]; let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_46]; let __cu = unconstrained; 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 __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; @@ -12996,10 +13015,10 @@ fn aiur_fn_96( let __v_53: G = __r_arr[6]; let __v_54: G = __r_arr[7]; let __v_55: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_55]; let __cu = unconstrained; 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_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_57]; let __cu = unconstrained; 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 __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -13009,24 +13028,24 @@ fn aiur_fn_96( let __v_64: G = __r_arr[6]; let __v_65: G = __r_arr[7]; let __v_66: G = __r_arr[8]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; - let __ret: [G; OUT_96] = [__v_3, __v_4, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_56, __v_67, __v_68]; - if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_97] = [__v_3, __v_4, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_56, __v_67, __v_68]; + if 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_97: usize = 1; -const IN_97: usize = 1; -const OUT_97: usize = 0; -fn aiur_fn_97( - inp: [G; IN_97], +const INPUT_SIZE_98: usize = 1; +const IN_98: usize = 1; +const OUT_98: usize = 0; +fn aiur_fn_98( + inp: [G; IN_98], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_97], ExecError> { +) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(2); @@ -13035,28 +13054,28 @@ fn aiur_fn_97( if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("Bool byte is not 0 or 1".to_string()) }); } - let __ret: [G; OUT_97] = []; - if let Some(result) = record.function_queries[97].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_98] = []; + if 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_98: usize = 1; -const IN_98: usize = 1; -const OUT_98: usize = 11; -fn aiur_fn_98( - inp: [G; IN_98], +const INPUT_SIZE_99: usize = 1; +const IN_99: usize = 1; +const OUT_99: usize = 11; +fn aiur_fn_99( + inp: [G; IN_99], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_98], ExecError> { +) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; 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_75] = { let __args: [G; IN_75] = [__v_2]; 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 __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13066,49 +13085,49 @@ fn aiur_fn_98( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_98] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; - if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_99] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; + if 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_99: usize = 1; -const IN_99: usize = 1; -const OUT_99: usize = 1; -fn aiur_fn_99( - inp: [G; IN_99], +const INPUT_SIZE_100: usize = 1; +const IN_100: usize = 1; +const OUT_100: usize = 1; +fn aiur_fn_100( + inp: [G; IN_100], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_99], ExecError> { +) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_99] = [__v_1]; - if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_100] = [__v_1]; + if 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); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_99] = [__v_1]; - if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_100] = [__v_1]; + if 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); }, 2u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_99] = [__v_1]; - if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_100] = [__v_1]; + if 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); }, 3u64 => { let __v_1: G = G::from_u64(3); - let __ret: [G; OUT_99] = [__v_1]; - if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_100] = [__v_1]; + if 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); }, _ => { @@ -13118,23 +13137,23 @@ fn aiur_fn_99( }) } -const INPUT_SIZE_100: usize = 1; -const IN_100: usize = 1; -const OUT_100: usize = 11; -fn aiur_fn_100( - inp: [G; IN_100], +const INPUT_SIZE_101: usize = 1; +const IN_101: usize = 1; +const OUT_101: usize = 11; +fn aiur_fn_101( + inp: [G; IN_101], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_100], ExecError> { +) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; 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 __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -13144,31 +13163,31 @@ fn aiur_fn_100( let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_12]; let __cu = unconstrained; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_100] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14]; - if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_101] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14]; + if 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_101: usize = 1; -const IN_101: usize = 1; -const OUT_101: usize = 35; -fn aiur_fn_101( - inp: [G; IN_101], +const INPUT_SIZE_102: usize = 1; +const IN_102: usize = 1; +const OUT_102: usize = 35; +fn aiur_fn_102( + inp: [G; IN_102], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_101], ExecError> { +) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; 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_75] = { let __args: [G; IN_75] = [__v_2]; 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 __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13178,7 +13197,7 @@ fn aiur_fn_101( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_11]; let __cu = unconstrained; 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 __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -13188,7 +13207,7 @@ fn aiur_fn_101( let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_20]; let __cu = unconstrained; 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 __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -13198,7 +13217,7 @@ fn aiur_fn_101( let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_29]; let __cu = unconstrained; 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 __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = __r_arr[2]; @@ -13208,24 +13227,24 @@ fn aiur_fn_101( let __v_36: G = __r_arr[6]; let __v_37: G = __r_arr[7]; let __v_38: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_38]; let __cu = unconstrained; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __ret: [G; OUT_101] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40]; - if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_102] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40]; + if 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_102: usize = 9; -const IN_102: usize = 9; -const OUT_102: usize = 2; -fn aiur_fn_102( - inp: [G; IN_102], +const INPUT_SIZE_103: usize = 9; +const IN_103: usize = 9; +const OUT_103: usize = 2; +fn aiur_fn_103( + inp: [G; IN_103], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_102], ExecError> { +) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13236,19 +13255,19 @@ fn aiur_fn_102( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_102] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_103] = [__v_12, __v_0]; + 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 __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0]; let __cu = unconstrained; 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 __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13284,7 +13303,7 @@ fn aiur_fn_102( let __v_42: G = __r_arr[32]; let __v_43: G = __r_arr[33]; let __v_44: G = __r_arr[34]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; @@ -13293,13 +13312,13 @@ fn aiur_fn_102( let __v_50: G = __r_arr[5]; let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; 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_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = G::from_u64(0); let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_102] = [__v_56, __v_54]; - if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_103] = [__v_56, __v_54]; + 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); }, _ => { @@ -13309,18 +13328,18 @@ fn aiur_fn_102( }) } -const INPUT_SIZE_103: usize = 1; -const IN_103: usize = 1; -const OUT_103: usize = 28; -fn aiur_fn_103( - inp: [G; IN_103], +const INPUT_SIZE_104: usize = 1; +const IN_104: usize = 1; +const OUT_104: usize = 28; +fn aiur_fn_104( + inp: [G; IN_104], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_103], ExecError> { +) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; @@ -13332,7 +13351,7 @@ fn aiur_fn_103( let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; 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 __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -13342,7 +13361,7 @@ fn aiur_fn_103( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_19]; let __cu = unconstrained; 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 __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -13352,7 +13371,7 @@ fn aiur_fn_103( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_28]; let __cu = unconstrained; 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 __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -13362,10 +13381,10 @@ fn aiur_fn_103( let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_37]; let __cu = unconstrained; 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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_39]; let __cu = unconstrained; 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 __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; @@ -13375,27 +13394,27 @@ fn aiur_fn_103( let __v_46: G = __r_arr[6]; let __v_47: G = __r_arr[7]; let __v_48: G = __r_arr[8]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __ret: [G; OUT_103] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_49, __v_50]; - if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_104] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_49, __v_50]; + if 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); }) } -const INPUT_SIZE_104: usize = 1; -const IN_104: usize = 1; -const OUT_104: usize = 10; -fn aiur_fn_104( - inp: [G; IN_104], +const INPUT_SIZE_105: usize = 1; +const IN_105: usize = 1; +const OUT_105: usize = 10; +fn aiur_fn_105( + inp: [G; IN_105], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_104], ExecError> { +) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13405,27 +13424,27 @@ fn aiur_fn_104( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_104] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; - if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_105] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; + if 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); }) } -const INPUT_SIZE_105: usize = 1; -const IN_105: usize = 1; -const OUT_105: usize = 18; -fn aiur_fn_105( - inp: [G; IN_105], +const INPUT_SIZE_106: usize = 1; +const IN_106: usize = 1; +const OUT_106: usize = 18; +fn aiur_fn_106( + inp: [G; IN_106], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_105], ExecError> { +) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13435,7 +13454,7 @@ fn aiur_fn_105( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_9]; let __cu = unconstrained; 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 __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13445,32 +13464,32 @@ fn aiur_fn_105( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_18]; let __cu = unconstrained; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_105] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20]; - if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_106] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20]; + if 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_106: usize = 1; -const IN_106: usize = 1; -const OUT_106: usize = 46; -fn aiur_fn_106( - inp: [G; IN_106], +const INPUT_SIZE_107: usize = 1; +const IN_107: usize = 1; +const OUT_107: usize = 46; +fn aiur_fn_107( + inp: [G; IN_107], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_106], ExecError> { +) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_93(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_2]; let __cu = unconstrained; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13486,12 +13505,12 @@ fn aiur_fn_106( let __v_15: G = __r_arr[12]; let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_106] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15]; - if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_107] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15]; + if 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); }, 1u64 => { - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_2]; let __cu = unconstrained; 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 = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13522,12 +13541,12 @@ fn aiur_fn_106( let __v_30: G = __r_arr[27]; let __v_31: G = G::from_u64(1); let __v_32: G = G::from_u64(0); - let __ret: [G; OUT_106] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30]; - if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_107] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30]; + if 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); }, 2u64 => { - let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13574,8 +13593,8 @@ fn aiur_fn_106( let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; let __v_48: G = G::from_u64(2); - let __ret: [G; OUT_106] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_107] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; + if 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); }, _ => { @@ -13585,15 +13604,15 @@ fn aiur_fn_106( }) } -const INPUT_SIZE_107: usize = 9; -const IN_107: usize = 9; -const OUT_107: usize = 2; -fn aiur_fn_107( - inp: [G; IN_107], +const INPUT_SIZE_108: usize = 9; +const IN_108: usize = 9; +const OUT_108: usize = 2; +fn aiur_fn_108( + inp: [G; IN_108], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_107], ExecError> { +) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13604,19 +13623,19 @@ fn aiur_fn_107( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_107] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_108] = [__v_12, __v_0]; + 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); }, 0u64 => { - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13663,7 +13682,7 @@ fn aiur_fn_107( let __v_53: G = __r_arr[43]; let __v_54: G = __r_arr[44]; let __v_55: G = __r_arr[45]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -13672,13 +13691,13 @@ fn aiur_fn_107( let __v_61: G = __r_arr[5]; let __v_62: G = __r_arr[6]; let __v_63: G = __r_arr[7]; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; 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_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_107] = [__v_67, __v_65]; - if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_108] = [__v_67, __v_65]; + 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); }, _ => { @@ -13688,21 +13707,21 @@ fn aiur_fn_107( }) } -const INPUT_SIZE_108: usize = 2; -const IN_108: usize = 2; -const OUT_108: usize = 46; -fn aiur_fn_108( - inp: [G; IN_108], +const INPUT_SIZE_109: usize = 2; +const IN_109: usize = 2; +const OUT_109: usize = 46; +fn aiur_fn_109( + inp: [G; IN_109], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_108], ExecError> { +) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_93(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13718,12 +13737,12 @@ fn aiur_fn_108( let __v_14: G = __r_arr[12]; let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_108] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14]; + if 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); }, 1u64 => { - let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13770,12 +13789,12 @@ fn aiur_fn_108( let __v_45: G = __r_arr[43]; let __v_46: G = __r_arr[44]; let __v_47: G = G::from_u64(1); - let __ret: [G; OUT_108] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; + if 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); }, 2u64 => { - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13789,12 +13808,12 @@ fn aiur_fn_108( let __v_12: G = __r_arr[10]; let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_108] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; + if 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); }, 3u64 => { - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13808,12 +13827,12 @@ fn aiur_fn_108( let __v_12: G = __r_arr[10]; let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_108] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; + if 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); }, 4u64 => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13834,12 +13853,12 @@ fn aiur_fn_108( let __v_19: G = __r_arr[17]; let __v_20: G = G::from_u64(4); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_108] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19]; + if 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); }, 5u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13852,12 +13871,12 @@ fn aiur_fn_108( let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(5); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_108] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + if 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); }, 6u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13870,12 +13889,12 @@ fn aiur_fn_108( let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(6); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_108] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + if 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); }, 7u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13888,8 +13907,8 @@ fn aiur_fn_108( let __v_11: G = __r_arr[9]; let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_108] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_109] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + if 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); }, _ => { @@ -13899,15 +13918,15 @@ fn aiur_fn_108( }) } -const INPUT_SIZE_109: usize = 10; -const IN_109: usize = 10; -const OUT_109: usize = 46; -fn aiur_fn_109( - inp: [G; IN_109], +const INPUT_SIZE_110: usize = 10; +const IN_110: usize = 10; +const OUT_110: usize = 46; +fn aiur_fn_110( + inp: [G; IN_110], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_109], ExecError> { +) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13921,13 +13940,13 @@ fn aiur_fn_109( let __v_9: G = inp[9]; match __v_0.as_canonical_u64() { 12u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(8); let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_109] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_110] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + if 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); }, 13u64 => { @@ -13941,7 +13960,7 @@ fn aiur_fn_109( if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) }); } - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; @@ -13988,8 +14007,8 @@ fn aiur_fn_109( let __v_60: G = __r_arr[43]; let __v_61: G = __r_arr[44]; let __v_62: G = __r_arr[45]; - let __ret: [G; OUT_109] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_110] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; + if 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); }, _ => { @@ -13999,18 +14018,18 @@ fn aiur_fn_109( }) } -const INPUT_SIZE_110: usize = 1; -const IN_110: usize = 1; -const OUT_110: usize = 49; -fn aiur_fn_110( - inp: [G; IN_110], +const INPUT_SIZE_111: usize = 1; +const IN_111: usize = 1; +const OUT_111: usize = 49; +fn aiur_fn_111( + inp: [G; IN_111], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_110], ExecError> { +) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; 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 __v_3: G = __r_arr[2]; @@ -14023,7 +14042,7 @@ fn aiur_fn_110( let __v_10: G = __r_arr[9]; let __mc_out___mc_0: [G; 46] = '__mc_0: { match __v_1.as_canonical_u64() { 12u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(8); @@ -14041,7 +14060,7 @@ fn aiur_fn_110( if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) }); } - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -14141,7 +14160,7 @@ fn aiur_fn_110( let __v_54: G = __mc_out___mc_0[43]; let __v_55: G = __mc_out___mc_0[44]; let __v_56: G = __mc_out___mc_0[45]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_56]; let __cu = unconstrained; 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 __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -14151,10 +14170,10 @@ fn aiur_fn_110( let __v_63: G = __r_arr[6]; let __v_64: G = __r_arr[7]; let __v_65: G = __r_arr[8]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; 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_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_67]; let __cu = unconstrained; 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 __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = __r_arr[2]; @@ -14164,10 +14183,10 @@ fn aiur_fn_110( let __v_74: G = __r_arr[6]; let __v_75: G = __r_arr[7]; let __v_76: G = __r_arr[8]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; 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_77: G = __r_arr[0]; let __v_78: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_78]; let __cu = unconstrained; 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 __v_79: G = __r_arr[0]; let __v_80: G = __r_arr[1]; let __v_81: G = __r_arr[2]; @@ -14177,24 +14196,24 @@ fn aiur_fn_110( let __v_85: G = __r_arr[6]; let __v_86: G = __r_arr[7]; let __v_87: G = __r_arr[8]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; - let __ret: [G; OUT_110] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_66, __v_77, __v_88, __v_89]; - if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_111] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_66, __v_77, __v_88, __v_89]; + if 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); }) } -const INPUT_SIZE_111: usize = 1; -const IN_111: usize = 1; -const OUT_111: usize = 2; -fn aiur_fn_111( - inp: [G; IN_111], +const INPUT_SIZE_112: usize = 1; +const IN_112: usize = 1; +const OUT_112: usize = 2; +fn aiur_fn_112( + inp: [G; IN_112], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_111], ExecError> { +) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -14204,36 +14223,36 @@ fn aiur_fn_111( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_111] = [__v_5, __v_7]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_5, __v_7]; + if 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); }, _ => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_111] = [__v_0, __v_7]; - if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_112] = [__v_0, __v_7]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_112: usize = 1; -const IN_112: usize = 1; -const OUT_112: usize = 1; -fn aiur_fn_112( - inp: [G; IN_112], +const INPUT_SIZE_113: usize = 1; +const IN_113: usize = 1; +const OUT_113: usize = 1; +fn aiur_fn_113( + inp: [G; IN_113], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_112], ExecError> { +) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -14262,8 +14281,8 @@ fn aiur_fn_112( let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_112] = [__v_23]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_113] = [__v_23]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -14275,7 +14294,7 @@ fn aiur_fn_112( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -14289,17 +14308,17 @@ fn aiur_fn_112( 0u64 => { let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_112] = [__v_29]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_113] = [__v_29]; + 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); }, _ => { let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; 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_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_112] = [__v_30]; - if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_113] = [__v_30]; + 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); }, } @@ -14311,15 +14330,15 @@ fn aiur_fn_112( }) } -const INPUT_SIZE_113: usize = 3; -const IN_113: usize = 3; -const OUT_113: usize = 1; -fn aiur_fn_113( - inp: [G; IN_113], +const INPUT_SIZE_114: usize = 3; +const IN_114: usize = 3; +const OUT_114: usize = 1; +fn aiur_fn_114( + inp: [G; IN_114], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_113], ExecError> { +) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14339,15 +14358,15 @@ fn aiur_fn_113( 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_113] = [__v_1]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_1]; + if 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); }, _ => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_1]; let __cu = unconstrained; 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_13: G = __r_arr[0]; - let __ret: [G; OUT_113] = [__v_13]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_13]; + if 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); }, } @@ -14368,21 +14387,21 @@ fn aiur_fn_113( 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_113] = [__v_0]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_0]; + if 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); }, _ => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0]; let __cu = unconstrained; 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_23: G = __r_arr[0]; - let __ret: [G; OUT_113] = [__v_23]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_23]; + if 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 __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -14399,7 +14418,7 @@ fn aiur_fn_113( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -14411,11 +14430,11 @@ fn aiur_fn_113( let __v_47: G = __r_arr[8]; let __v_48: G = (__v_31 + __v_47); let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; 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_50: G = __r_arr[0]; let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_113] = [__v_51]; - if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_114] = [__v_51]; + 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); }, _ => { @@ -14430,36 +14449,36 @@ fn aiur_fn_113( }) } -const INPUT_SIZE_114: usize = 2; -const IN_114: usize = 2; -const OUT_114: usize = 1; -fn aiur_fn_114( - inp: [G; IN_114], +const INPUT_SIZE_115: usize = 2; +const IN_115: usize = 2; +const OUT_115: usize = 1; +fn aiur_fn_115( + inp: [G; IN_115], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_114], ExecError> { +) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; 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_3: G = __r_arr[0]; - let __ret: [G; OUT_114] = [__v_3]; - if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_115] = [__v_3]; + if 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); }) } -const INPUT_SIZE_115: usize = 16; -const IN_115: usize = 16; -const OUT_115: usize = 9; -fn aiur_fn_115( - inp: [G; IN_115], +const INPUT_SIZE_116: usize = 16; +const IN_116: usize = 16; +const OUT_116: usize = 9; +fn aiur_fn_116( + inp: [G; IN_116], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_115], ExecError> { +) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14529,21 +14548,21 @@ fn aiur_fn_115( let __v_50: G = __b2_sub.0; let __v_51: G = __b2_sub.1; let __v_52: G = (__v_49 + __v_51); - let __ret: [G; OUT_115] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; - if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_116] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; + if 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_116: usize = 3; -const IN_116: usize = 3; -const OUT_116: usize = 2; -fn aiur_fn_116( - inp: [G; IN_116], +const INPUT_SIZE_117: usize = 3; +const IN_117: usize = 3; +const OUT_117: usize = 2; +fn aiur_fn_117( + inp: [G; IN_117], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_116], ExecError> { +) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14577,20 +14596,20 @@ fn aiur_fn_116( let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_116] = [__v_25, __v_2]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_25, __v_2]; + 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); }, 0u64 => { - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; 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_23: G = __r_arr[0]; match __v_23.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_116] = [__v_26, __v_2]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_26, __v_2]; + 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); }, _ => { @@ -14598,8 +14617,8 @@ fn aiur_fn_116( let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(1); - let __ret: [G; OUT_116] = [__v_26, __v_27]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_26, __v_27]; + if 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); }, } @@ -14626,8 +14645,8 @@ fn aiur_fn_116( match __v_2.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_116] = [__v_0, __v_23]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_0, __v_23]; + if 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); }, _ => { @@ -14639,7 +14658,7 @@ fn aiur_fn_116( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; 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_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -14652,19 +14671,19 @@ fn aiur_fn_116( let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_116] = [__v_46, __v_44]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_46, __v_44]; + 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); }, } }, 0u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; 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_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -14681,7 +14700,7 @@ fn aiur_fn_116( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; 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_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -14692,13 +14711,13 @@ fn aiur_fn_116( let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = (__v_31 + __v_47); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_116] = [__v_52, __v_50]; - if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_117] = [__v_52, __v_50]; + 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); }, _ => { @@ -14713,15 +14732,15 @@ fn aiur_fn_116( }) } -const INPUT_SIZE_117: usize = 1; -const IN_117: usize = 1; -const OUT_117: usize = 1; -fn aiur_fn_117( - inp: [G; IN_117], +const INPUT_SIZE_118: usize = 1; +const IN_118: usize = 1; +const OUT_118: usize = 1; +fn aiur_fn_118( + inp: [G; IN_118], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_117], ExecError> { +) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -14740,8 +14759,8 @@ fn aiur_fn_117( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_117] = [__v_13]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_118] = [__v_13]; + if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -14750,11 +14769,11 @@ fn aiur_fn_117( if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; 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_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 10] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_117] = [__v_13]; - if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_118] = [__v_13]; + if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14764,15 +14783,15 @@ fn aiur_fn_117( }) } -const INPUT_SIZE_118: usize = 1; -const IN_118: usize = 1; -const OUT_118: usize = 1; -fn aiur_fn_118( - inp: [G; IN_118], +const INPUT_SIZE_119: usize = 1; +const IN_119: usize = 1; +const OUT_119: usize = 1; +fn aiur_fn_119( + inp: [G; IN_119], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_118], ExecError> { +) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -14791,12 +14810,12 @@ fn aiur_fn_118( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_118] = [__v_13]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_119] = [__v_13]; + 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 __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10]; let __cu = unconstrained; 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_11: G = __r_arr[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -14811,15 +14830,15 @@ fn aiur_fn_118( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_118] = [__v_25]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_119] = [__v_25]; + 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 => { @@ -14828,8 +14847,8 @@ fn aiur_fn_118( let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_118] = [__v_27]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_119] = [__v_27]; + 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); }, _ => { @@ -14840,8 +14859,8 @@ fn aiur_fn_118( _ => { let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_118] = [__v_23]; - if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_119] = [__v_23]; + 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); }, } @@ -14853,20 +14872,20 @@ fn aiur_fn_118( }) } -const INPUT_SIZE_119: usize = 2; -const IN_119: usize = 2; -const OUT_119: usize = 1; -fn aiur_fn_119( - inp: [G; IN_119], +const INPUT_SIZE_120: usize = 2; +const IN_120: usize = 2; +const OUT_120: usize = 1; +fn aiur_fn_120( + inp: [G; IN_120], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_119], ExecError> { +) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -14874,15 +14893,15 @@ fn aiur_fn_119( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_119] = [__v_7]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_7]; + 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_118] = { let __args: [G; IN_118] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3]; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __ret: [G; OUT_119] = [__v_5]; - if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_120] = [__v_5]; + if 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); }, _ => { @@ -14892,19 +14911,19 @@ fn aiur_fn_119( }) } -const INPUT_SIZE_120: usize = 2; -const IN_120: usize = 2; -const OUT_120: usize = 1; -fn aiur_fn_120( - inp: [G; IN_120], +const INPUT_SIZE_121: usize = 2; +const IN_121: usize = 2; +const OUT_121: usize = 1; +fn aiur_fn_121( + inp: [G; IN_121], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_120], ExecError> { +) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_1]; let __cu = unconstrained; 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_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]; @@ -14920,29 +14939,29 @@ fn aiur_fn_120( match __v_3.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_120] = [__v_13]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_121] = [__v_13]; + if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_120] = [__v_13]; - if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_121] = [__v_13]; + if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_121: usize = 1; -const IN_121: usize = 1; -const OUT_121: usize = 1; -fn aiur_fn_121( - inp: [G; IN_121], +const INPUT_SIZE_122: usize = 1; +const IN_122: usize = 1; +const OUT_122: usize = 1; +fn aiur_fn_122( + inp: [G; IN_122], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_121], ExecError> { +) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -14958,23 +14977,23 @@ fn aiur_fn_121( let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_121] = [__v_14]; - if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_122] = [__v_14]; + if 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); }) } -const INPUT_SIZE_122: usize = 2; -const IN_122: usize = 2; -const OUT_122: usize = 2; -fn aiur_fn_122( - inp: [G; IN_122], +const INPUT_SIZE_123: usize = 2; +const IN_123: usize = 2; +const OUT_123: usize = 2; +fn aiur_fn_123( + inp: [G; IN_123], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_122], ExecError> { +) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14982,8 +15001,8 @@ fn aiur_fn_122( let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_122] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_123] = [__v_0, __v_1]; + if 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 => { @@ -14991,11 +15010,11 @@ fn aiur_fn_122( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_5, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_122] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_123] = [__v_8, __v_9]; + if 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); }, _ => { @@ -15005,40 +15024,40 @@ fn aiur_fn_122( }) } -const INPUT_SIZE_123: usize = 1; -const IN_123: usize = 1; -const OUT_123: usize = 3; -fn aiur_fn_123( - inp: [G; IN_123], +const INPUT_SIZE_124: usize = 1; +const IN_124: usize = 1; +const OUT_124: usize = 3; +fn aiur_fn_124( + inp: [G; IN_124], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_123], ExecError> { +) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_123] = [__v_2, __v_5, __v_6]; - if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_124] = [__v_2, __v_5, __v_6]; + if 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_124: usize = 16; -const IN_124: usize = 16; -const OUT_124: usize = 16; -fn aiur_fn_124( - inp: [G; IN_124], +const INPUT_SIZE_125: usize = 16; +const IN_125: usize = 16; +const OUT_125: usize = 16; +fn aiur_fn_125( + inp: [G; IN_125], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_124], ExecError> { +) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15169,7 +15188,7 @@ fn aiur_fn_124( let __v_126: G = (__v_7 * __v_14); let __v_127: G = (__v_125 + __v_126); let __v_128: G = (__v_7 * __v_15); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_16]; let __cu = true; 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 { 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_129: G = __r_arr[0]; let __v_130: G = __r_arr[1]; let __v_131: G = __r_arr[2]; @@ -15192,7 +15211,7 @@ fn aiur_fn_124( if (__v_16 != __v_147) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_147.as_canonical_u64(), msg: Some("u64_mul column 0: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_141]; let __cu = true; 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 { 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_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __v_150: G = __r_arr[2]; @@ -15215,7 +15234,7 @@ fn aiur_fn_124( if (__v_141 != __v_166) { return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("u64_mul column 1: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_160]; let __cu = true; 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 { 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_167: G = __r_arr[0]; let __v_168: G = __r_arr[1]; let __v_169: G = __r_arr[2]; @@ -15238,7 +15257,7 @@ fn aiur_fn_124( if (__v_160 != __v_185) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("u64_mul column 2: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_179]; let __cu = true; 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 { 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_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __v_188: G = __r_arr[2]; @@ -15261,7 +15280,7 @@ fn aiur_fn_124( if (__v_179 != __v_204) { return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_204.as_canonical_u64(), msg: Some("u64_mul column 3: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_198]; let __cu = true; 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 { 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_205: G = __r_arr[0]; let __v_206: G = __r_arr[1]; let __v_207: G = __r_arr[2]; @@ -15284,7 +15303,7 @@ fn aiur_fn_124( if (__v_198 != __v_223) { return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_223.as_canonical_u64(), msg: Some("u64_mul column 4: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_217]; let __cu = true; 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 { 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_224: G = __r_arr[0]; let __v_225: G = __r_arr[1]; let __v_226: G = __r_arr[2]; @@ -15307,7 +15326,7 @@ fn aiur_fn_124( if (__v_217 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u64_mul column 5: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_236]; let __cu = true; 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 { 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_243: G = __r_arr[0]; let __v_244: G = __r_arr[1]; let __v_245: G = __r_arr[2]; @@ -15330,7 +15349,7 @@ fn aiur_fn_124( if (__v_236 != __v_261) { return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_261.as_canonical_u64(), msg: Some("u64_mul column 6: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_255]; let __cu = true; 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 { 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_262: G = __r_arr[0]; let __v_263: G = __r_arr[1]; let __v_264: G = __r_arr[2]; @@ -15353,7 +15372,7 @@ fn aiur_fn_124( if (__v_255 != __v_280) { return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_280.as_canonical_u64(), msg: Some("u64_mul column 7: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_274]; let __cu = true; 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 { 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_281: G = __r_arr[0]; let __v_282: G = __r_arr[1]; let __v_283: G = __r_arr[2]; @@ -15376,7 +15395,7 @@ fn aiur_fn_124( if (__v_274 != __v_299) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_299.as_canonical_u64(), msg: Some("u64_mul column 8: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_293]; let __cu = true; 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 { 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_300: G = __r_arr[0]; let __v_301: G = __r_arr[1]; let __v_302: G = __r_arr[2]; @@ -15399,7 +15418,7 @@ fn aiur_fn_124( if (__v_293 != __v_318) { return Err(ExecError::AssertEqMismatch { lhs: __v_293.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u64_mul column 9: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_312]; let __cu = true; 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 { 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_319: G = __r_arr[0]; let __v_320: G = __r_arr[1]; let __v_321: G = __r_arr[2]; @@ -15422,7 +15441,7 @@ fn aiur_fn_124( if (__v_312 != __v_337) { return Err(ExecError::AssertEqMismatch { lhs: __v_312.as_canonical_u64(), rhs: __v_337.as_canonical_u64(), msg: Some("u64_mul column 10: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_331]; let __cu = true; 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 { 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_338: G = __r_arr[0]; let __v_339: G = __r_arr[1]; let __v_340: G = __r_arr[2]; @@ -15445,7 +15464,7 @@ fn aiur_fn_124( if (__v_331 != __v_356) { return Err(ExecError::AssertEqMismatch { lhs: __v_331.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: Some("u64_mul column 11: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_350]; let __cu = true; 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 { 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_357: G = __r_arr[0]; let __v_358: G = __r_arr[1]; let __v_359: G = __r_arr[2]; @@ -15468,7 +15487,7 @@ fn aiur_fn_124( if (__v_350 != __v_375) { return Err(ExecError::AssertEqMismatch { lhs: __v_350.as_canonical_u64(), rhs: __v_375.as_canonical_u64(), msg: Some("u64_mul column 12: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_369]; let __cu = true; 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 { 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_376: G = __r_arr[0]; let __v_377: G = __r_arr[1]; let __v_378: G = __r_arr[2]; @@ -15491,7 +15510,7 @@ fn aiur_fn_124( if (__v_369 != __v_394) { return Err(ExecError::AssertEqMismatch { lhs: __v_369.as_canonical_u64(), rhs: __v_394.as_canonical_u64(), msg: Some("u64_mul column 13: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_388]; let __cu = true; 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 { 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_395: G = __r_arr[0]; let __v_396: G = __r_arr[1]; let __v_397: G = __r_arr[2]; @@ -15513,21 +15532,21 @@ fn aiur_fn_124( if (__v_388 != __v_412) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u64_mul column 14: split_carry hint does not recompose to the column sum".to_string()) }); } - let __ret: [G; OUT_124] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406]; - if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_125] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406]; + if 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); }) } -const INPUT_SIZE_125: usize = 2; -const IN_125: usize = 2; -const OUT_125: usize = 1; -fn aiur_fn_125( - inp: [G; IN_125], +const INPUT_SIZE_126: usize = 2; +const IN_126: usize = 2; +const OUT_126: usize = 1; +fn aiur_fn_126( + inp: [G; IN_126], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_125], ExecError> { +) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15535,23 +15554,23 @@ fn aiur_fn_125( let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_125] = [__v_6]; - if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_126] = [__v_6]; + if 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_126: usize = 4; -const IN_126: usize = 4; -const OUT_126: usize = 1; -fn aiur_fn_126( - inp: [G; IN_126], +const INPUT_SIZE_127: usize = 4; +const IN_127: usize = 4; +const OUT_127: usize = 1; +fn aiur_fn_127( + inp: [G; IN_127], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_126], ExecError> { +) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15570,8 +15589,8 @@ fn aiur_fn_126( let __v_13: G = __loaded[9]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_126] = [__v_2]; - if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_127] = [__v_2]; + if 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); }, 0u64 => { @@ -15586,18 +15605,18 @@ fn aiur_fn_126( let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_25, __v_3]; let __cu = unconstrained; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2, __v_26]; let __cu = unconstrained; 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_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = (__v_3 + __v_28); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; 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_30: G = __r_arr[0]; - let __ret: [G; OUT_126] = [__v_30]; - if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_127] = [__v_30]; + if 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); }, _ => { @@ -15607,15 +15626,15 @@ fn aiur_fn_126( }) } -const INPUT_SIZE_127: usize = 18; -const IN_127: usize = 18; -const OUT_127: usize = 1; -fn aiur_fn_127( - inp: [G; IN_127], +const INPUT_SIZE_128: usize = 18; +const IN_128: usize = 18; +const OUT_128: usize = 1; +fn aiur_fn_128( + inp: [G; IN_128], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_127], ExecError> { +) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15648,19 +15667,19 @@ fn aiur_fn_127( let __v_27: G = __loaded[9]; match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_127] = [__v_17]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_17]; + if 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 => { let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_127] = [__v_29]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_29]; + if 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); }, _ => { @@ -15669,7 +15688,7 @@ fn aiur_fn_127( } }, 0u64 => { - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -15686,7 +15705,7 @@ fn aiur_fn_127( let __v_41: G = __r_arr[13]; let __v_42: G = __r_arr[14]; let __v_43: G = __r_arr[15]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -15703,7 +15722,7 @@ fn aiur_fn_127( let __v_57: G = G::from_u64(0); let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = __r_arr[1]; let __v_62: G = __r_arr[2]; @@ -15715,10 +15734,10 @@ fn aiur_fn_127( let __v_68: G = __r_arr[8]; let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; 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_70: G = __r_arr[0]; - let __ret: [G; OUT_127] = [__v_70]; - if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_128] = [__v_70]; + if 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); }, _ => { @@ -15728,22 +15747,22 @@ fn aiur_fn_127( }) } -const INPUT_SIZE_128: usize = 2; -const IN_128: usize = 2; -const OUT_128: usize = 1; -fn aiur_fn_128( - inp: [G; IN_128], +const INPUT_SIZE_129: usize = 2; +const IN_129: usize = 2; +const OUT_129: usize = 1; +fn aiur_fn_129( + inp: [G; IN_129], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_128], ExecError> { +) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_128] = [__v_0]; - if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_129] = [__v_0]; + if 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); }, _ => { @@ -15759,28 +15778,28 @@ fn aiur_fn_128( let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_11, __v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; - let __ret: [G; OUT_128] = [__v_14]; - if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_129] = [__v_14]; + if 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); }, } }) } -const INPUT_SIZE_129: usize = 1; -const IN_129: usize = 1; -const OUT_129: usize = 1; -fn aiur_fn_129( - inp: [G; IN_129], +const INPUT_SIZE_130: usize = 1; +const IN_130: usize = 1; +const OUT_130: usize = 1; +fn aiur_fn_130( + inp: [G; IN_130], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_129], ExecError> { +) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; let __cu = unconstrained; 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_1: G = __r_arr[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -15796,79 +15815,79 @@ fn aiur_fn_129( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_129] = [__v_12]; - if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_130] = [__v_12]; + if 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); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_129] = [__v_12]; - if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_130] = [__v_12]; + if 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); }, } }) } -const INPUT_SIZE_130: usize = 2; -const IN_130: usize = 2; -const OUT_130: usize = 2; -fn aiur_fn_130( - inp: [G; IN_130], +const INPUT_SIZE_131: usize = 2; +const IN_131: usize = 2; +const OUT_131: usize = 2; +fn aiur_fn_131( + inp: [G; IN_131], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_130], ExecError> { +) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __bu_qr: (G, G) = unconstrained_big_uint_div_mod_helper(__v_0, __v_1, record)?; let __v_2: G = __bu_qr.0; let __v_3: G = __bu_qr.1; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2]; let __cu = unconstrained; 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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3]; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_6]; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_1]; let __cu = unconstrained; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8, __v_7]; let __cu = unconstrained; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; let __cu = unconstrained; 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_11: G = __r_arr[0]; if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("div/mod hint: q*b + r != a".to_string()) }); } - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_5]; let __cu = unconstrained; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("div/mod hint: division by zero must yield a zero quotient".to_string()) }); } - let __ret: [G; OUT_130] = [__v_5, __v_7]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_131] = [__v_5, __v_7]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7]; let __cu = unconstrained; 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_13: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __v_1]; let __cu = unconstrained; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("div/mod hint: remainder is not less than the divisor".to_string()) }); } - let __ret: [G; OUT_130] = [__v_5, __v_7]; - if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_131] = [__v_5, __v_7]; + if 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); }, _ => { @@ -15878,27 +15897,6 @@ fn aiur_fn_130( }) } -const INPUT_SIZE_131: usize = 2; -const IN_131: usize = 2; -const OUT_131: usize = 1; -fn aiur_fn_131( - inp: [G; IN_131], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_131], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; - let __v_2: G = __r_arr[0]; - let __v_3: G = __r_arr[1]; - let __ret: [G; OUT_131] = [__v_2]; - if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - const INPUT_SIZE_132: usize = 2; const IN_132: usize = 2; const OUT_132: usize = 1; @@ -15911,10 +15909,10 @@ fn aiur_fn_132( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __ret: [G; OUT_132] = [__v_3]; + let __ret: [G; OUT_132] = [__v_2]; 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); }) @@ -15932,21 +15930,42 @@ fn aiur_fn_133( 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_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __ret: [G; OUT_133] = [__v_3]; + 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 = 2; +const IN_134: usize = 2; +const OUT_134: usize = 1; +fn aiur_fn_134( + inp: [G; IN_134], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_134], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_133] = [__v_0]; - if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_134] = [__v_0]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1]; let __cu = unconstrained; 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_3: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; - let __ret: [G; OUT_133] = [__v_4]; - if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_134] = [__v_4]; + if 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); }, _ => { @@ -15956,19 +15975,19 @@ fn aiur_fn_133( }) } -const INPUT_SIZE_134: usize = 2; -const IN_134: usize = 2; -const OUT_134: usize = 1; -fn aiur_fn_134( - inp: [G; IN_134], +const INPUT_SIZE_135: usize = 2; +const IN_135: usize = 2; +const OUT_135: usize = 1; +fn aiur_fn_135( + inp: [G; IN_135], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_134], ExecError> { +) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { @@ -15985,8 +16004,8 @@ fn aiur_fn_134( let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_134] = [__v_15]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_135] = [__v_15]; + if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -16003,30 +16022,30 @@ fn aiur_fn_134( let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_0]; let __cu = unconstrained; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_16]; let __cu = unconstrained; 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_20: G = __r_arr[0]; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_19, __v_20]; let __cu = unconstrained; 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 __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_134] = [__v_21]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_135] = [__v_21]; + if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_21]; let __cu = unconstrained; 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_23: G = __r_arr[0]; - let __ret: [G; OUT_134] = [__v_23]; - if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_135] = [__v_23]; + if 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); }, _ => { @@ -16041,15 +16060,15 @@ fn aiur_fn_134( }) } -const INPUT_SIZE_135: usize = 16; -const IN_135: usize = 16; -const OUT_135: usize = 8; -fn aiur_fn_135( - inp: [G; IN_135], +const INPUT_SIZE_136: usize = 16; +const IN_136: usize = 16; +const OUT_136: usize = 8; +fn aiur_fn_136( + inp: [G; IN_136], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_135], ExecError> { +) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16075,21 +16094,21 @@ fn aiur_fn_135( let __v_21: G = if unconstrained { Bytes2::and(&__v_5, &__v_13) } else { bytes2_and_value(__v_5, __v_13, record) }; let __v_22: G = if unconstrained { Bytes2::and(&__v_6, &__v_14) } else { bytes2_and_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { Bytes2::and(&__v_7, &__v_15) } else { bytes2_and_value(__v_7, __v_15, record) }; - let __ret: [G; OUT_135] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_136] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + if 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); }) } -const INPUT_SIZE_136: usize = 16; -const IN_136: usize = 16; -const OUT_136: usize = 8; -fn aiur_fn_136( - inp: [G; IN_136], +const INPUT_SIZE_137: usize = 16; +const IN_137: usize = 16; +const OUT_137: usize = 8; +fn aiur_fn_137( + inp: [G; IN_137], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_136], ExecError> { +) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16115,21 +16134,21 @@ fn aiur_fn_136( let __v_21: G = if unconstrained { Bytes2::or(&__v_5, &__v_13) } else { bytes2_or_value(__v_5, __v_13, record) }; let __v_22: G = if unconstrained { Bytes2::or(&__v_6, &__v_14) } else { bytes2_or_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { Bytes2::or(&__v_7, &__v_15) } else { bytes2_or_value(__v_7, __v_15, record) }; - let __ret: [G; OUT_136] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_137] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + if 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_137: usize = 16; -const IN_137: usize = 16; -const OUT_137: usize = 8; -fn aiur_fn_137( - inp: [G; IN_137], +const INPUT_SIZE_138: usize = 16; +const IN_138: usize = 16; +const OUT_138: usize = 8; +fn aiur_fn_138( + inp: [G; IN_138], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_137], ExecError> { +) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16155,95 +16174,12 @@ fn aiur_fn_137( let __v_21: G = if unconstrained { Bytes2::xor(&__v_5, &__v_13) } else { bytes2_xor_value(__v_5, __v_13, record) }; let __v_22: G = if unconstrained { Bytes2::xor(&__v_6, &__v_14) } else { bytes2_xor_value(__v_6, __v_14, record) }; let __v_23: G = if unconstrained { Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record) }; - let __ret: [G; OUT_137] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_138] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + if 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); }) } -const INPUT_SIZE_138: usize = 2; -const IN_138: usize = 2; -const OUT_138: usize = 1; -fn aiur_fn_138( - inp: [G; IN_138], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_138], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; - let __v_2: G = __loaded[0]; - let __v_3: G = __loaded[1]; - let __v_4: G = __loaded[2]; - let __v_5: G = __loaded[3]; - let __v_6: G = __loaded[4]; - let __v_7: G = __loaded[5]; - let __v_8: G = __loaded[6]; - let __v_9: G = __loaded[7]; - let __v_10: G = __loaded[8]; - let __v_11: G = __loaded[9]; - match __v_2.as_canonical_u64() { - 1u64 => { - let __v_12: G = G::from_u64(1); - let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_138] = [__v_14]; - if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; - let __v_12: G = __loaded[0]; - let __v_13: G = __loaded[1]; - let __v_14: G = __loaded[2]; - let __v_15: G = __loaded[3]; - let __v_16: G = __loaded[4]; - let __v_17: G = __loaded[5]; - let __v_18: G = __loaded[6]; - let __v_19: G = __loaded[7]; - let __v_20: G = __loaded[8]; - let __v_21: G = __loaded[9]; - match __v_12.as_canonical_u64() { - 1u64 => { - let __v_22: G = G::from_u64(1); - let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_138] = [__v_24]; - if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; - let __v_23: G = __r_arr[0]; - let __v_24: G = __r_arr[1]; - let __v_25: G = __r_arr[2]; - let __v_26: G = __r_arr[3]; - let __v_27: G = __r_arr[4]; - let __v_28: G = __r_arr[5]; - let __v_29: G = __r_arr[6]; - let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; - let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_138] = [__v_32]; - if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); - }, - } - }) -} - const INPUT_SIZE_139: usize = 2; const IN_139: usize = 2; const OUT_139: usize = 1; @@ -16269,7 +16205,10 @@ fn aiur_fn_139( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_139] = [__v_1]; + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_139] = [__v_14]; 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); }, @@ -16287,7 +16226,10 @@ fn aiur_fn_139( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_139] = [__v_0]; + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_139] = [__v_24]; 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); }, @@ -16407,6 +16349,83 @@ fn aiur_fn_141( 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 __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_141] = [__v_1]; + 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); + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + let __v_16: G = __loaded[4]; + let __v_17: G = __loaded[5]; + let __v_18: G = __loaded[6]; + let __v_19: G = __loaded[7]; + let __v_20: G = __loaded[8]; + let __v_21: G = __loaded[9]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_141] = [__v_0]; + 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); + }, + 0u64 => { + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; 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_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_141] = [__v_32]; + if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_142: usize = 2; +const IN_142: usize = 2; +const OUT_142: usize = 1; +fn aiur_fn_142( + inp: [G; IN_142], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16423,25 +16442,25 @@ fn aiur_fn_141( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_14, __v_1]; 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_15: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_15]; let __cu = unconstrained; 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_16: G = __r_arr[0]; - let __ret: [G; OUT_141] = [__v_16]; - if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_142] = [__v_16]; + if 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); }) } -const INPUT_SIZE_142: usize = 2; -const IN_142: usize = 2; -const OUT_142: usize = 1; -fn aiur_fn_142( - inp: [G; IN_142], +const INPUT_SIZE_143: usize = 2; +const IN_143: usize = 2; +const OUT_143: usize = 1; +fn aiur_fn_143( + inp: [G; IN_143], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_142], ExecError> { +) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16458,25 +16477,25 @@ fn aiur_fn_142( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_14, __v_1]; 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_15: G = __r_arr[0]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_15]; let __cu = unconstrained; 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_16: G = __r_arr[0]; - let __ret: [G; OUT_142] = [__v_16]; - if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_143] = [__v_16]; + if 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); }) } -const INPUT_SIZE_143: usize = 0; -const IN_143: usize = 0; -const OUT_143: usize = 1; -fn aiur_fn_143( - inp: [G; IN_143], +const INPUT_SIZE_144: usize = 0; +const IN_144: usize = 0; +const OUT_144: usize = 1; +fn aiur_fn_144( + inp: [G; IN_144], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_143], ExecError> { +) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(211); let __v_1: G = G::from_u64(151); @@ -16511,21 +16530,21 @@ fn aiur_fn_143( let __v_30: G = G::from_u64(125); let __v_31: G = G::from_u64(182); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_143] = [__v_32]; - if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_144] = [__v_32]; + if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_144: usize = 0; -const IN_144: usize = 0; -const OUT_144: usize = 1; -fn aiur_fn_144( - inp: [G; IN_144], +const INPUT_SIZE_145: usize = 0; +const IN_145: usize = 0; +const OUT_145: usize = 1; +fn aiur_fn_145( + inp: [G; IN_145], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_144], ExecError> { +) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(222); let __v_1: G = G::from_u64(245); @@ -16560,21 +16579,21 @@ fn aiur_fn_144( let __v_30: G = G::from_u64(5); let __v_31: G = G::from_u64(110); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_144] = [__v_32]; - if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_145] = [__v_32]; + if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_145: usize = 0; -const IN_145: usize = 0; -const OUT_145: usize = 1; -fn aiur_fn_145( - inp: [G; IN_145], +const INPUT_SIZE_146: usize = 0; +const IN_146: usize = 0; +const OUT_146: usize = 1; +fn aiur_fn_146( + inp: [G; IN_146], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_145], ExecError> { +) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(145); let __v_1: G = G::from_u64(79); @@ -16609,21 +16628,21 @@ fn aiur_fn_145( let __v_30: G = G::from_u64(76); let __v_31: G = G::from_u64(136); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_145] = [__v_32]; - if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_146] = [__v_32]; + if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_146: usize = 0; -const IN_146: usize = 0; -const OUT_146: usize = 1; -fn aiur_fn_146( - inp: [G; IN_146], +const INPUT_SIZE_147: usize = 0; +const IN_147: usize = 0; +const OUT_147: usize = 1; +fn aiur_fn_147( + inp: [G; IN_147], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_146], ExecError> { +) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(9); let __v_1: G = G::from_u64(188); @@ -16658,21 +16677,21 @@ fn aiur_fn_146( let __v_30: G = G::from_u64(211); let __v_31: G = G::from_u64(220); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_146] = [__v_32]; - if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_147] = [__v_32]; + if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_147: usize = 0; -const IN_147: usize = 0; -const OUT_147: usize = 1; -fn aiur_fn_147( - inp: [G; IN_147], +const INPUT_SIZE_148: usize = 0; +const IN_148: usize = 0; +const OUT_148: usize = 1; +fn aiur_fn_148( + inp: [G; IN_148], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_147], ExecError> { +) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(38); let __v_1: G = G::from_u64(124); @@ -16707,21 +16726,21 @@ fn aiur_fn_147( let __v_30: G = G::from_u64(73); let __v_31: G = G::from_u64(241); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_147] = [__v_32]; - if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_148] = [__v_32]; + if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_148: usize = 0; -const IN_148: usize = 0; -const OUT_148: usize = 1; -fn aiur_fn_148( - inp: [G; IN_148], +const INPUT_SIZE_149: usize = 0; +const IN_149: usize = 0; +const OUT_149: usize = 1; +fn aiur_fn_149( + inp: [G; IN_149], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_148], ExecError> { +) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(182); let __v_1: G = G::from_u64(187); @@ -16756,21 +16775,21 @@ fn aiur_fn_148( let __v_30: G = G::from_u64(233); let __v_31: G = G::from_u64(38); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_148] = [__v_32]; - if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_149] = [__v_32]; + if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_149: usize = 0; -const IN_149: usize = 0; -const OUT_149: usize = 1; -fn aiur_fn_149( - inp: [G; IN_149], +const INPUT_SIZE_150: usize = 0; +const IN_150: usize = 0; +const OUT_150: usize = 1; +fn aiur_fn_150( + inp: [G; IN_150], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_149], ExecError> { +) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(188); let __v_1: G = G::from_u64(176); @@ -16805,21 +16824,21 @@ fn aiur_fn_149( let __v_30: G = G::from_u64(211); let __v_31: G = G::from_u64(137); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_149] = [__v_32]; - if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_150] = [__v_32]; + if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_150: usize = 0; -const IN_150: usize = 0; -const OUT_150: usize = 1; -fn aiur_fn_150( - inp: [G; IN_150], +const INPUT_SIZE_151: usize = 0; +const IN_151: usize = 0; +const OUT_151: usize = 1; +fn aiur_fn_151( + inp: [G; IN_151], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_150], ExecError> { +) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(116); let __v_1: G = G::from_u64(237); @@ -16854,21 +16873,21 @@ fn aiur_fn_150( let __v_30: G = G::from_u64(190); let __v_31: G = G::from_u64(16); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_150] = [__v_32]; - if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_151] = [__v_32]; + if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_151: usize = 0; -const IN_151: usize = 0; -const OUT_151: usize = 1; -fn aiur_fn_151( - inp: [G; IN_151], +const INPUT_SIZE_152: usize = 0; +const IN_152: usize = 0; +const OUT_152: usize = 1; +fn aiur_fn_152( + inp: [G; IN_152], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_151], ExecError> { +) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(246); let __v_1: G = G::from_u64(28); @@ -16903,21 +16922,21 @@ fn aiur_fn_151( let __v_30: G = G::from_u64(78); let __v_31: G = G::from_u64(189); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_151] = [__v_32]; - if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_152] = [__v_32]; + if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_152: usize = 0; -const IN_152: usize = 0; -const OUT_152: usize = 1; -fn aiur_fn_152( - inp: [G; IN_152], +const INPUT_SIZE_153: usize = 0; +const IN_153: usize = 0; +const OUT_153: usize = 1; +fn aiur_fn_153( + inp: [G; IN_153], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_152], ExecError> { +) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(172); let __v_1: G = G::from_u64(156); @@ -16952,21 +16971,21 @@ fn aiur_fn_152( let __v_30: G = G::from_u64(192); let __v_31: G = G::from_u64(112); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_152] = [__v_32]; - if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_153] = [__v_32]; + if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_153: usize = 0; -const IN_153: usize = 0; -const OUT_153: usize = 1; -fn aiur_fn_153( - inp: [G; IN_153], +const INPUT_SIZE_154: usize = 0; +const IN_154: usize = 0; +const OUT_154: usize = 1; +fn aiur_fn_154( + inp: [G; IN_154], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_153], ExecError> { +) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(159); let __v_1: G = G::from_u64(44); @@ -17001,21 +17020,21 @@ fn aiur_fn_153( let __v_30: G = G::from_u64(15); let __v_31: G = G::from_u64(91); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_153] = [__v_32]; - if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_154] = [__v_32]; + if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_154: usize = 0; -const IN_154: usize = 0; -const OUT_154: usize = 1; -fn aiur_fn_154( - inp: [G; IN_154], +const INPUT_SIZE_155: usize = 0; +const IN_155: usize = 0; +const OUT_155: usize = 1; +fn aiur_fn_155( + inp: [G; IN_155], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_154], ExecError> { +) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(25); let __v_1: G = G::from_u64(125); @@ -17050,21 +17069,21 @@ fn aiur_fn_154( let __v_30: G = G::from_u64(66); let __v_31: G = G::from_u64(113); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_154] = [__v_32]; - if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_155] = [__v_32]; + if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_155: usize = 0; -const IN_155: usize = 0; -const OUT_155: usize = 1; -fn aiur_fn_155( - inp: [G; IN_155], +const INPUT_SIZE_156: usize = 0; +const IN_156: usize = 0; +const OUT_156: usize = 1; +fn aiur_fn_156( + inp: [G; IN_156], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_155], ExecError> { +) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(7); let __v_1: G = G::from_u64(19); @@ -17099,21 +17118,21 @@ fn aiur_fn_155( let __v_30: G = G::from_u64(127); let __v_31: G = G::from_u64(87); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_155] = [__v_32]; - if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_156] = [__v_32]; + if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_156: usize = 0; -const IN_156: usize = 0; -const OUT_156: usize = 1; -fn aiur_fn_156( - inp: [G; IN_156], +const INPUT_SIZE_157: usize = 0; +const IN_157: usize = 0; +const OUT_157: usize = 1; +fn aiur_fn_157( + inp: [G; IN_157], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_156], ExecError> { +) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(131); let __v_1: G = G::from_u64(227); @@ -17148,21 +17167,21 @@ fn aiur_fn_156( let __v_30: G = G::from_u64(124); let __v_31: G = G::from_u64(164); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_156] = [__v_32]; - if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_157] = [__v_32]; + if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_157: usize = 0; -const IN_157: usize = 0; -const OUT_157: usize = 1; -fn aiur_fn_157( - inp: [G; IN_157], +const INPUT_SIZE_158: usize = 0; +const IN_158: usize = 0; +const OUT_158: usize = 1; +fn aiur_fn_158( + inp: [G; IN_158], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_157], ExecError> { +) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(135); let __v_1: G = G::from_u64(91); @@ -17197,21 +17216,21 @@ fn aiur_fn_157( let __v_30: G = G::from_u64(76); let __v_31: G = G::from_u64(16); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_157] = [__v_32]; - if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_158] = [__v_32]; + if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_158: usize = 0; -const IN_158: usize = 0; -const OUT_158: usize = 1; -fn aiur_fn_158( - inp: [G; IN_158], +const INPUT_SIZE_159: usize = 0; +const IN_159: usize = 0; +const OUT_159: usize = 1; +fn aiur_fn_159( + inp: [G; IN_159], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_158], ExecError> { +) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(225); let __v_1: G = G::from_u64(238); @@ -17246,21 +17265,21 @@ fn aiur_fn_158( let __v_30: G = G::from_u64(147); let __v_31: G = G::from_u64(229); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_158] = [__v_32]; - if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_159] = [__v_32]; + if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_159: usize = 0; -const IN_159: usize = 0; -const OUT_159: usize = 1; -fn aiur_fn_159( - inp: [G; IN_159], +const INPUT_SIZE_160: usize = 0; +const IN_160: usize = 0; +const OUT_160: usize = 1; +fn aiur_fn_160( + inp: [G; IN_160], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_159], ExecError> { +) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(191); let __v_1: G = G::from_u64(5); @@ -17295,21 +17314,21 @@ fn aiur_fn_159( let __v_30: G = G::from_u64(125); let __v_31: G = G::from_u64(87); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_159] = [__v_32]; - if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_160] = [__v_32]; + if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_160: usize = 0; -const IN_160: usize = 0; -const OUT_160: usize = 1; -fn aiur_fn_160( - inp: [G; IN_160], +const INPUT_SIZE_161: usize = 0; +const IN_161: usize = 0; +const OUT_161: usize = 1; +fn aiur_fn_161( + inp: [G; IN_161], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_160], ExecError> { +) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(194); let __v_1: G = G::from_u64(254); @@ -17344,21 +17363,21 @@ fn aiur_fn_160( let __v_30: G = G::from_u64(75); let __v_31: G = G::from_u64(7); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_160] = [__v_32]; - if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_161] = [__v_32]; + if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_161: usize = 0; -const IN_161: usize = 0; -const OUT_161: usize = 1; -fn aiur_fn_161( - inp: [G; IN_161], +const INPUT_SIZE_162: usize = 0; +const IN_162: usize = 0; +const OUT_162: usize = 1; +fn aiur_fn_162( + inp: [G; IN_162], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_161], ExecError> { +) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(10); let __v_1: G = G::from_u64(236); @@ -17393,21 +17412,21 @@ fn aiur_fn_161( let __v_30: G = G::from_u64(84); let __v_31: G = G::from_u64(128); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_161] = [__v_32]; - if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_162] = [__v_32]; + if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_162: usize = 0; -const IN_162: usize = 0; -const OUT_162: usize = 1; -fn aiur_fn_162( - inp: [G; IN_162], +const INPUT_SIZE_163: usize = 0; +const IN_163: usize = 0; +const OUT_163: usize = 1; +fn aiur_fn_163( + inp: [G; IN_163], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_162], ExecError> { +) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(89); let __v_1: G = G::from_u64(228); @@ -17442,21 +17461,21 @@ fn aiur_fn_162( let __v_30: G = G::from_u64(206); let __v_31: G = G::from_u64(66); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_162] = [__v_32]; - if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_163] = [__v_32]; + if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_163: usize = 0; -const IN_163: usize = 0; -const OUT_163: usize = 1; -fn aiur_fn_163( - inp: [G; IN_163], +const INPUT_SIZE_164: usize = 0; +const IN_164: usize = 0; +const OUT_164: usize = 1; +fn aiur_fn_164( + inp: [G; IN_164], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_163], ExecError> { +) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(44); let __v_1: G = G::from_u64(157); @@ -17491,21 +17510,21 @@ fn aiur_fn_163( let __v_30: G = G::from_u64(171); let __v_31: G = G::from_u64(207); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_163] = [__v_32]; - if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_164] = [__v_32]; + if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_164: usize = 0; -const IN_164: usize = 0; -const OUT_164: usize = 1; -fn aiur_fn_164( - inp: [G; IN_164], +const INPUT_SIZE_165: usize = 0; +const IN_165: usize = 0; +const OUT_165: usize = 1; +fn aiur_fn_165( + inp: [G; IN_165], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_164], ExecError> { +) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(47); let __v_1: G = G::from_u64(18); @@ -17540,21 +17559,21 @@ fn aiur_fn_164( let __v_30: G = G::from_u64(113); let __v_31: G = G::from_u64(49); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_164] = [__v_32]; - if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_165] = [__v_32]; + if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_165: usize = 0; -const IN_165: usize = 0; -const OUT_165: usize = 1; -fn aiur_fn_165( - inp: [G; IN_165], +const INPUT_SIZE_166: usize = 0; +const IN_166: usize = 0; +const OUT_166: usize = 1; +fn aiur_fn_166( + inp: [G; IN_166], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_165], ExecError> { +) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(131); let __v_1: G = G::from_u64(60); @@ -17589,21 +17608,21 @@ fn aiur_fn_165( let __v_30: G = G::from_u64(14); let __v_31: G = G::from_u64(52); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_165] = [__v_32]; - if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_166] = [__v_32]; + if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_166: usize = 0; -const IN_166: usize = 0; -const OUT_166: usize = 1; -fn aiur_fn_166( - inp: [G; IN_166], +const INPUT_SIZE_167: usize = 0; +const IN_167: usize = 0; +const OUT_167: usize = 1; +fn aiur_fn_167( + inp: [G; IN_167], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_166], ExecError> { +) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(114); let __v_1: G = G::from_u64(50); @@ -17638,21 +17657,21 @@ fn aiur_fn_166( let __v_30: G = G::from_u64(171); let __v_31: G = G::from_u64(154); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_166] = [__v_32]; - if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_167] = [__v_32]; + if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_167: usize = 0; -const IN_167: usize = 0; -const OUT_167: usize = 1; -fn aiur_fn_167( - inp: [G; IN_167], +const INPUT_SIZE_168: usize = 0; +const IN_168: usize = 0; +const OUT_168: usize = 1; +fn aiur_fn_168( + inp: [G; IN_168], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_167], ExecError> { +) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(195); let __v_1: G = G::from_u64(176); @@ -17687,21 +17706,21 @@ fn aiur_fn_167( let __v_30: G = G::from_u64(4); let __v_31: G = G::from_u64(240); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_167] = [__v_32]; - if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_168] = [__v_32]; + if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_168: usize = 0; -const IN_168: usize = 0; -const OUT_168: usize = 1; -fn aiur_fn_168( - inp: [G; IN_168], +const INPUT_SIZE_169: usize = 0; +const IN_169: usize = 0; +const OUT_169: usize = 1; +fn aiur_fn_169( + inp: [G; IN_169], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_168], ExecError> { +) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(110); let __v_1: G = G::from_u64(112); @@ -17736,21 +17755,21 @@ fn aiur_fn_168( let __v_30: G = G::from_u64(9); let __v_31: G = G::from_u64(120); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_168] = [__v_32]; - if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_169] = [__v_32]; + if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_169: usize = 0; -const IN_169: usize = 0; -const OUT_169: usize = 1; -fn aiur_fn_169( - inp: [G; IN_169], +const INPUT_SIZE_170: usize = 0; +const IN_170: usize = 0; +const OUT_170: usize = 1; +fn aiur_fn_170( + inp: [G; IN_170], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_169], ExecError> { +) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(216); let __v_1: G = G::from_u64(221); @@ -17785,21 +17804,21 @@ fn aiur_fn_169( let __v_30: G = G::from_u64(249); let __v_31: G = G::from_u64(243); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_169] = [__v_32]; - if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_170] = [__v_32]; + if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_170: usize = 0; -const IN_170: usize = 0; -const OUT_170: usize = 1; -fn aiur_fn_170( - inp: [G; IN_170], +const INPUT_SIZE_171: usize = 0; +const IN_171: usize = 0; +const OUT_171: usize = 1; +fn aiur_fn_171( + inp: [G; IN_171], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_170], ExecError> { +) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(202); let __v_1: G = G::from_u64(48); @@ -17834,21 +17853,21 @@ fn aiur_fn_170( let __v_30: G = G::from_u64(32); let __v_31: G = G::from_u64(112); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_170] = [__v_32]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_171] = [__v_32]; + if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_171: usize = 0; -const IN_171: usize = 0; -const OUT_171: usize = 1; -fn aiur_fn_171( - inp: [G; IN_171], +const INPUT_SIZE_172: usize = 0; +const IN_172: usize = 0; +const OUT_172: usize = 1; +fn aiur_fn_172( + inp: [G; IN_172], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_171], ExecError> { +) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(202); let __v_1: G = G::from_u64(75); @@ -17883,21 +17902,21 @@ fn aiur_fn_171( let __v_30: G = G::from_u64(28); let __v_31: G = G::from_u64(188); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_171] = [__v_32]; - if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_172] = [__v_32]; + if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_172: usize = 0; -const IN_172: usize = 0; -const OUT_172: usize = 1; -fn aiur_fn_172( - inp: [G; IN_172], +const INPUT_SIZE_173: usize = 0; +const IN_173: usize = 0; +const OUT_173: usize = 1; +fn aiur_fn_173( + inp: [G; IN_173], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_172], ExecError> { +) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(162); let __v_1: G = G::from_u64(154); @@ -17932,21 +17951,21 @@ fn aiur_fn_172( let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(98); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_172] = [__v_32]; - if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_173] = [__v_32]; + if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_173: usize = 0; -const IN_173: usize = 0; -const OUT_173: usize = 1; -fn aiur_fn_173( - inp: [G; IN_173], +const INPUT_SIZE_174: usize = 0; +const IN_174: usize = 0; +const OUT_174: usize = 1; +fn aiur_fn_174( + inp: [G; IN_174], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_173], ExecError> { +) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(221); let __v_1: G = G::from_u64(161); @@ -17981,21 +18000,21 @@ fn aiur_fn_173( let __v_30: G = G::from_u64(198); let __v_31: G = G::from_u64(62); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_173] = [__v_32]; - if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_174] = [__v_32]; + if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_174: usize = 0; -const IN_174: usize = 0; -const OUT_174: usize = 1; -fn aiur_fn_174( - inp: [G; IN_174], +const INPUT_SIZE_175: usize = 0; +const IN_175: usize = 0; +const OUT_175: usize = 1; +fn aiur_fn_175( + inp: [G; IN_175], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_174], ExecError> { +) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(169); let __v_1: G = G::from_u64(22); @@ -18030,21 +18049,21 @@ fn aiur_fn_174( let __v_30: G = G::from_u64(250); let __v_31: G = G::from_u64(236); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_174] = [__v_32]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_175] = [__v_32]; + if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_175: usize = 0; -const IN_175: usize = 0; -const OUT_175: usize = 1; -fn aiur_fn_175( - inp: [G; IN_175], +const INPUT_SIZE_176: usize = 0; +const IN_176: usize = 0; +const OUT_176: usize = 1; +fn aiur_fn_176( + inp: [G; IN_176], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_175], ExecError> { +) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(123); let __v_1: G = G::from_u64(216); @@ -18079,21 +18098,21 @@ fn aiur_fn_175( let __v_30: G = G::from_u64(64); let __v_31: G = G::from_u64(18); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_175] = [__v_32]; - if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_176] = [__v_32]; + if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_176: usize = 0; -const IN_176: usize = 0; -const OUT_176: usize = 1; -fn aiur_fn_176( - inp: [G; IN_176], +const INPUT_SIZE_177: usize = 0; +const IN_177: usize = 0; +const OUT_177: usize = 1; +fn aiur_fn_177( + inp: [G; IN_177], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_176], ExecError> { +) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(28); let __v_1: G = G::from_u64(23); @@ -18128,21 +18147,21 @@ fn aiur_fn_176( let __v_30: G = G::from_u64(250); let __v_31: G = G::from_u64(120); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_176] = [__v_32]; - if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_177] = [__v_32]; + if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_177: usize = 0; -const IN_177: usize = 0; -const OUT_177: usize = 1; -fn aiur_fn_177( - inp: [G; IN_177], +const INPUT_SIZE_178: usize = 0; +const IN_178: usize = 0; +const OUT_178: usize = 1; +fn aiur_fn_178( + inp: [G; IN_178], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_177], ExecError> { +) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(22); let __v_1: G = G::from_u64(133); @@ -18177,21 +18196,21 @@ fn aiur_fn_177( let __v_30: G = G::from_u64(229); let __v_31: G = G::from_u64(96); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_177] = [__v_32]; - if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_178] = [__v_32]; + if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_178: usize = 0; -const IN_178: usize = 0; -const OUT_178: usize = 1; -fn aiur_fn_178( - inp: [G; IN_178], +const INPUT_SIZE_179: usize = 0; +const IN_179: usize = 0; +const OUT_179: usize = 1; +fn aiur_fn_179( + inp: [G; IN_179], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_178], ExecError> { +) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(12); let __v_1: G = G::from_u64(112); @@ -18226,21 +18245,21 @@ fn aiur_fn_178( let __v_30: G = G::from_u64(108); let __v_31: G = G::from_u64(113); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_178] = [__v_32]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_179] = [__v_32]; + if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_179: usize = 0; -const IN_179: usize = 0; -const OUT_179: usize = 1; -fn aiur_fn_179( - inp: [G; IN_179], +const INPUT_SIZE_180: usize = 0; +const IN_180: usize = 0; +const OUT_180: usize = 1; +fn aiur_fn_180( + inp: [G; IN_180], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_179], ExecError> { +) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(102); let __v_1: G = G::from_u64(242); @@ -18275,86 +18294,86 @@ fn aiur_fn_179( let __v_30: G = G::from_u64(189); let __v_31: G = G::from_u64(213); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_179] = [__v_32]; - if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_180] = [__v_32]; + 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); }) } -const INPUT_SIZE_180: usize = 1; -const IN_180: usize = 1; -const OUT_180: usize = 1; -fn aiur_fn_180( - inp: [G; IN_180], +const INPUT_SIZE_181: usize = 1; +const IN_181: usize = 1; +const OUT_181: usize = 1; +fn aiur_fn_181( + inp: [G; IN_181], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_180], ExecError> { +) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; 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_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_180] = [__v_3]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_3]; + if 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 __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; 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_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_180] = [__v_5]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_5]; + if 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 __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_180] = [__v_7]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_7]; + if 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 __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_180] = [__v_9]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_9]; + if 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 __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_180] = [__v_11]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_11]; + if 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_11: G = G::from_u64(0); - let __ret: [G; OUT_180] = [__v_11]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_11]; + if 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); }, } @@ -18369,15 +18388,15 @@ fn aiur_fn_180( }) } -const INPUT_SIZE_181: usize = 0; -const IN_181: usize = 0; -const OUT_181: usize = 1; -fn aiur_fn_181( - inp: [G; IN_181], +const INPUT_SIZE_182: usize = 0; +const IN_182: usize = 0; +const OUT_182: usize = 1; +fn aiur_fn_182( + inp: [G; IN_182], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_181], ExecError> { +) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(64); @@ -18396,21 +18415,21 @@ fn aiur_fn_181( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_181] = [__v_16]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_16]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_182: usize = 0; -const IN_182: usize = 0; -const OUT_182: usize = 1; -fn aiur_fn_182( - inp: [G; IN_182], +const INPUT_SIZE_183: usize = 0; +const IN_183: usize = 0; +const OUT_183: usize = 1; +fn aiur_fn_183( + inp: [G; IN_183], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_182], ExecError> { +) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(1); @@ -18429,74 +18448,74 @@ fn aiur_fn_182( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_182] = [__v_16]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_16]; + 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); }) } -const INPUT_SIZE_183: usize = 3; -const IN_183: usize = 3; -const OUT_183: usize = 2; -fn aiur_fn_183( - inp: [G; IN_183], +const INPUT_SIZE_184: usize = 3; +const IN_184: usize = 3; +const OUT_184: usize = 2; +fn aiur_fn_184( + inp: [G; IN_184], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_183], ExecError> { +) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; 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_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_183] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_5, __v_6]; + if 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); }, _ => { - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __cu = unconstrained; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_183] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_7, __v_8]; + if 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); }, _ => { - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_1]; let __cu = unconstrained; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_183] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_9, __v_10]; + if 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); }, _ => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; let __v_13: G = (__v_10 + __v_12); match __v_13.as_canonical_u64() { @@ -18506,8 +18525,8 @@ fn aiur_fn_183( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_183] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18522,8 +18541,8 @@ fn aiur_fn_183( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_183] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_17, __v_21]; + 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); }, _ => { @@ -18534,19 +18553,19 @@ fn aiur_fn_183( let __v_19: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __ret: [G; OUT_183] = [__v_20, __v_21]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_20, __v_21]; + if 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); }, _ => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __ret: [G; OUT_183] = [__v_20, __v_21]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_20, __v_21]; + if 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); }, } @@ -18563,15 +18582,15 @@ fn aiur_fn_183( }) } -const INPUT_SIZE_184: usize = 1; -const IN_184: usize = 1; -const OUT_184: usize = 2; -fn aiur_fn_184( - inp: [G; IN_184], +const INPUT_SIZE_185: usize = 1; +const IN_185: usize = 1; +const OUT_185: usize = 2; +fn aiur_fn_185( + inp: [G; IN_185], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_184], ExecError> { +) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; @@ -18585,15 +18604,15 @@ fn aiur_fn_184( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_184] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -18603,17 +18622,17 @@ fn aiur_fn_184( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; 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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __cu = unconstrained; 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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; 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_15: G = __r_arr[0]; - let __ret: [G; OUT_184] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_14, __v_15]; + if 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); }, _ => { @@ -18622,8 +18641,8 @@ fn aiur_fn_184( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_184] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_14, __v_18]; + 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); }, } @@ -18634,8 +18653,8 @@ fn aiur_fn_184( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_184] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_12, __v_16]; + 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); }, } @@ -18644,15 +18663,15 @@ fn aiur_fn_184( }) } -const INPUT_SIZE_185: usize = 1; -const IN_185: usize = 1; -const OUT_185: usize = 2; -fn aiur_fn_185( - inp: [G; IN_185], +const INPUT_SIZE_186: usize = 1; +const IN_186: usize = 1; +const OUT_186: usize = 2; +fn aiur_fn_186( + inp: [G; IN_186], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_185], ExecError> { +) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -18662,13 +18681,13 @@ fn aiur_fn_185( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; let __v_9: G = (__v_6 + __v_8); match __v_9.as_canonical_u64() { @@ -18678,14 +18697,14 @@ fn aiur_fn_185( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_185] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_185] = [__v_10, __v_0]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_10, __v_0]; + if 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); }, } @@ -18696,23 +18715,23 @@ fn aiur_fn_185( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_185] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_186: usize = 1; -const IN_186: usize = 1; -const OUT_186: usize = 2; -fn aiur_fn_186( - inp: [G; IN_186], +const INPUT_SIZE_187: usize = 1; +const IN_187: usize = 1; +const OUT_187: usize = 2; +fn aiur_fn_187( + inp: [G; IN_187], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_186], ExecError> { +) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -18725,8 +18744,8 @@ fn aiur_fn_186( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_186] = [__v_5, __v_0]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_5, __v_0]; + if 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); }, _ => { @@ -18735,8 +18754,8 @@ fn aiur_fn_186( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_5, __v_9]; + 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); }, } @@ -18747,23 +18766,23 @@ fn aiur_fn_186( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_187: usize = 0; -const IN_187: usize = 0; -const OUT_187: usize = 1; -fn aiur_fn_187( - inp: [G; IN_187], +const INPUT_SIZE_188: usize = 0; +const IN_188: usize = 0; +const OUT_188: usize = 1; +fn aiur_fn_188( + inp: [G; IN_188], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_187], ExecError> { +) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(227); let __v_1: G = G::from_u64(42); @@ -18798,21 +18817,21 @@ fn aiur_fn_187( let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(116); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_187] = [__v_32]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_32]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_188: usize = 0; -const IN_188: usize = 0; -const OUT_188: usize = 1; -fn aiur_fn_188( - inp: [G; IN_188], +const INPUT_SIZE_189: usize = 0; +const IN_189: usize = 0; +const OUT_189: usize = 1; +fn aiur_fn_189( + inp: [G; IN_189], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_188], ExecError> { +) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(59); let __v_1: G = G::from_u64(51); @@ -18847,21 +18866,21 @@ fn aiur_fn_188( let __v_30: G = G::from_u64(191); let __v_31: G = G::from_u64(110); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_32]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_189] = [__v_32]; + if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_189: usize = 0; -const IN_189: usize = 0; -const OUT_189: usize = 1; -fn aiur_fn_189( - inp: [G; IN_189], +const INPUT_SIZE_190: usize = 0; +const IN_190: usize = 0; +const OUT_190: usize = 1; +fn aiur_fn_190( + inp: [G; IN_190], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_189], ExecError> { +) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(103); let __v_1: G = G::from_u64(244); @@ -18896,21 +18915,21 @@ fn aiur_fn_189( let __v_30: G = G::from_u64(43); let __v_31: G = G::from_u64(164); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_189] = [__v_32]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_32]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_190: usize = 0; -const IN_190: usize = 0; -const OUT_190: usize = 1; -fn aiur_fn_190( - inp: [G; IN_190], +const INPUT_SIZE_191: usize = 0; +const IN_191: usize = 0; +const OUT_191: usize = 1; +fn aiur_fn_191( + inp: [G; IN_191], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_190], ExecError> { +) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(79); let __v_1: G = G::from_u64(157); @@ -18945,21 +18964,21 @@ fn aiur_fn_190( let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(204); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_190] = [__v_32]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_32]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_191: usize = 0; -const IN_191: usize = 0; -const OUT_191: usize = 1; -fn aiur_fn_191( - inp: [G; IN_191], +const INPUT_SIZE_192: usize = 0; +const IN_192: usize = 0; +const OUT_192: usize = 1; +fn aiur_fn_192( + inp: [G; IN_192], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_191], ExecError> { +) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(197); let __v_1: G = G::from_u64(247); @@ -18994,21 +19013,21 @@ fn aiur_fn_191( let __v_30: G = G::from_u64(55); let __v_31: G = G::from_u64(35); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_191] = [__v_32]; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_192] = [__v_32]; + if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_192: usize = 0; -const IN_192: usize = 0; -const OUT_192: usize = 1; -fn aiur_fn_192( - inp: [G; IN_192], +const INPUT_SIZE_193: usize = 0; +const IN_193: usize = 0; +const OUT_193: usize = 1; +fn aiur_fn_193( + inp: [G; IN_193], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_192], ExecError> { +) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(202); let __v_1: G = G::from_u64(202); @@ -19043,62 +19062,62 @@ fn aiur_fn_192( let __v_30: G = G::from_u64(51); let __v_31: G = G::from_u64(18); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_192] = [__v_32]; - if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_193] = [__v_32]; + 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_193: usize = 1; -const IN_193: usize = 1; -const OUT_193: usize = 1; -fn aiur_fn_193( - inp: [G; IN_193], +const INPUT_SIZE_194: usize = 1; +const IN_194: usize = 1; +const OUT_194: usize = 1; +fn aiur_fn_194( + inp: [G; IN_194], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_193], ExecError> { +) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __cu = unconstrained; 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_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_193] = [__v_3]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_3]; + if 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); }, _ => { - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_193] = [__v_5]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_5]; + if 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); }, _ => { - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_193] = [__v_7]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_7]; + if 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); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_193] = [__v_7]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_7]; + if 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); }, } @@ -19109,61 +19128,61 @@ fn aiur_fn_193( }) } -const INPUT_SIZE_194: usize = 1; -const IN_194: usize = 1; -const OUT_194: usize = 1; -fn aiur_fn_194( - inp: [G; IN_194], +const INPUT_SIZE_195: usize = 1; +const IN_195: usize = 1; +const OUT_195: usize = 1; +fn aiur_fn_195( + inp: [G; IN_195], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_194], ExecError> { +) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(2); - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_194] = [__v_7]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_195] = [__v_7]; + 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); }, _ => { let __v_1: G = G::from_u64(2); - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_194] = [__v_7]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_195] = [__v_7]; + 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_195: usize = 2; -const IN_195: usize = 2; -const OUT_195: usize = 2; -fn aiur_fn_195( - inp: [G; IN_195], +const INPUT_SIZE_196: usize = 2; +const IN_196: usize = 2; +const OUT_196: usize = 2; +fn aiur_fn_196( + inp: [G; IN_196], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_195], ExecError> { +) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -19173,12 +19192,12 @@ fn aiur_fn_195( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_195] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -19187,12 +19206,12 @@ fn aiur_fn_195( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_195] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_7, __v_10]; + 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); }, 1u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_3]; let __cu = unconstrained; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { @@ -19201,8 +19220,8 @@ fn aiur_fn_195( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_195] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_9, __v_12]; + 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); }, 1u64 => { @@ -19219,15 +19238,15 @@ fn aiur_fn_195( let __v_19: G = G::from_u64(1); let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_21, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_21, __v_8]; 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_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_6, __v_22]; let __cu = unconstrained; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_24]; let __cu = unconstrained; 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_25: G = __r_arr[0]; - let __ret: [G; OUT_195] = [__v_23, __v_25]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_23, __v_25]; + if 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); }, _ => { @@ -19247,15 +19266,15 @@ fn aiur_fn_195( }) } -const INPUT_SIZE_196: usize = 1; -const IN_196: usize = 1; -const OUT_196: usize = 2; -fn aiur_fn_196( - inp: [G; IN_196], +const INPUT_SIZE_197: usize = 1; +const IN_197: usize = 1; +const OUT_197: usize = 2; +fn aiur_fn_197( + inp: [G; IN_197], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_196], ExecError> { +) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; @@ -19269,8 +19288,8 @@ fn aiur_fn_196( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_196] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19283,7 +19302,7 @@ fn aiur_fn_196( let __v_8: G = G::from_u64(2); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5, __v_7]; let __cu = unconstrained; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { @@ -19293,12 +19312,12 @@ fn aiur_fn_196( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_196] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5, __v_9]; let __cu = unconstrained; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -19308,20 +19327,20 @@ fn aiur_fn_196( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_196] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __v_11]; let __cu = unconstrained; 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_15: G = __r_arr[0]; let __v_16: G = (__v_14 - __v_15); let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_16]; let __cu = unconstrained; 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_18: G = __r_arr[0]; - let __ret: [G; OUT_196] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_17, __v_18]; + if 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); }, _ => { @@ -19338,15 +19357,15 @@ fn aiur_fn_196( }) } -const INPUT_SIZE_197: usize = 1; -const IN_197: usize = 1; -const OUT_197: usize = 2; -fn aiur_fn_197( - inp: [G; IN_197], +const INPUT_SIZE_198: usize = 1; +const IN_198: usize = 1; +const OUT_198: usize = 2; +fn aiur_fn_198( + inp: [G; IN_198], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_197], ExecError> { +) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; @@ -19360,15 +19379,15 @@ fn aiur_fn_197( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_4, __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); }, _ => { let __v_4: G = G::from_u64(0); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19378,9 +19397,9 @@ fn aiur_fn_197( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; 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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __cu = unconstrained; 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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { @@ -19389,8 +19408,8 @@ fn aiur_fn_197( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_14, __v_18]; + 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); }, _ => { @@ -19405,15 +19424,15 @@ fn aiur_fn_197( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_17, __v_21]; + 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); }, _ => { let __v_17: G = G::from_u64(0); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19423,9 +19442,9 @@ fn aiur_fn_197( let __v_24: G = __loaded[3]; match __v_21.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_22, __v_25]; let __cu = unconstrained; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 0u64 => { @@ -19434,8 +19453,8 @@ fn aiur_fn_197( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_27, __v_31]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_27, __v_31]; + 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); }, _ => { @@ -19450,8 +19469,8 @@ fn aiur_fn_197( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_30, __v_34]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_30, __v_34]; + 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); }, _ => { @@ -19473,11 +19492,11 @@ fn aiur_fn_197( let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_44]; 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_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_197] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_45, __v_46]; + if 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); }, } @@ -19490,8 +19509,8 @@ fn aiur_fn_197( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_25, __v_29]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_25, __v_29]; + 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); }, } @@ -19506,8 +19525,8 @@ fn aiur_fn_197( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19516,18 +19535,18 @@ fn aiur_fn_197( }) } -const INPUT_SIZE_198: usize = 1; -const IN_198: usize = 1; -const OUT_198: usize = 3; -fn aiur_fn_198( - inp: [G; IN_198], +const INPUT_SIZE_199: usize = 1; +const IN_199: usize = 1; +const OUT_199: usize = 3; +fn aiur_fn_199( + inp: [G; IN_199], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_198], ExecError> { +) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -19537,9 +19556,9 @@ fn aiur_fn_198( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -19556,8 +19575,8 @@ fn aiur_fn_198( let __v_15: G = G::from_u64(1); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_198] = [__v_12, __v_14, __v_16]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_12, __v_14, __v_16]; + if 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); }, _ => { @@ -19570,8 +19589,8 @@ fn aiur_fn_198( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_12, __v_16, __v_20]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_12, __v_16, __v_20]; + 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); }, } @@ -19586,8 +19605,8 @@ fn aiur_fn_198( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_9, __v_13, __v_17]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_9, __v_13, __v_17]; + 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); }, } @@ -19602,30 +19621,30 @@ fn aiur_fn_198( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_7, __v_11, __v_15]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_7, __v_11, __v_15]; + 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_199: usize = 3; -const IN_199: usize = 3; -const OUT_199: usize = 2; -fn aiur_fn_199( - inp: [G; IN_199], +const INPUT_SIZE_200: usize = 3; +const IN_200: usize = 3; +const OUT_200: usize = 2; +fn aiur_fn_200( + inp: [G; IN_200], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_199], ExecError> { +) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { @@ -19640,8 +19659,8 @@ fn aiur_fn_199( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_8, __v_12]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_8, __v_12]; + 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); }, _ => { @@ -19653,7 +19672,7 @@ fn aiur_fn_199( let __v_11: G = G::from_u64(1); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_10, __v_12]; let __cu = unconstrained; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -19663,16 +19682,16 @@ fn aiur_fn_199( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_14]; let __cu = unconstrained; 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_16: G = __r_arr[0]; - let __ret: [G; OUT_199] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_15, __v_16]; + if 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); }, _ => { @@ -19683,33 +19702,33 @@ fn aiur_fn_199( } }, _ => { - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_2]; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_7]; let __cu = unconstrained; 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 __v_9: G = __r_arr[1]; - let __ret: [G; OUT_199] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_8, __v_9]; + if 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 __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_199] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_9, __v_10]; + if 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); }, _ => { @@ -19718,8 +19737,8 @@ fn aiur_fn_199( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_9, __v_13]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_9, __v_13]; + 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); }, } @@ -19730,15 +19749,15 @@ fn aiur_fn_199( }) } -const INPUT_SIZE_200: usize = 2; -const IN_200: usize = 2; -const OUT_200: usize = 1; -fn aiur_fn_200( - inp: [G; IN_200], +const INPUT_SIZE_201: usize = 2; +const IN_201: usize = 2; +const OUT_201: usize = 1; +fn aiur_fn_201( + inp: [G; IN_201], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_200], ExecError> { +) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -19750,8 +19769,8 @@ fn aiur_fn_200( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_200] = [__v_2]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_2]; + if 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 => { @@ -19761,8 +19780,8 @@ fn aiur_fn_200( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_200] = [__v_2]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_2]; + if 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 => { @@ -19772,14 +19791,14 @@ fn aiur_fn_200( let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_200] = [__v_2]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_2]; + if 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_201] = { let __args: [G; IN_201] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_7, __v_1]; let __cu = unconstrained; 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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_1]; let __cu = unconstrained; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); @@ -19787,8 +19806,8 @@ fn aiur_fn_200( let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_19]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_19]; + 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); }, _ => { @@ -19808,40 +19827,40 @@ fn aiur_fn_200( }) } -const INPUT_SIZE_201: usize = 2; -const IN_201: usize = 2; -const OUT_201: usize = 1; -fn aiur_fn_201( - inp: [G; IN_201], +const INPUT_SIZE_202: usize = 2; +const IN_202: usize = 2; +const OUT_202: usize = 1; +fn aiur_fn_202( + inp: [G; IN_202], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_201], ExecError> { +) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_201] = [__v_5]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_5]; + if 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); }) } -const INPUT_SIZE_202: usize = 0; -const IN_202: usize = 0; -const OUT_202: usize = 1; -fn aiur_fn_202( - inp: [G; IN_202], +const INPUT_SIZE_203: usize = 0; +const IN_203: usize = 0; +const OUT_203: usize = 1; +fn aiur_fn_203( + inp: [G; IN_203], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_202], ExecError> { +) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(81); let __v_1: G = G::from_u64(134); @@ -19876,21 +19895,21 @@ fn aiur_fn_202( let __v_30: G = G::from_u64(90); let __v_31: G = G::from_u64(110); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_32]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_32]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_203: usize = 0; -const IN_203: usize = 0; -const OUT_203: usize = 1; -fn aiur_fn_203( - inp: [G; IN_203], +const INPUT_SIZE_204: usize = 0; +const IN_204: usize = 0; +const OUT_204: usize = 1; +fn aiur_fn_204( + inp: [G; IN_204], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_203], ExecError> { +) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(255); let __v_1: G = G::from_u64(69); @@ -19925,21 +19944,21 @@ fn aiur_fn_203( let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(158); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_203] = [__v_32]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_204] = [__v_32]; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_204: usize = 0; -const IN_204: usize = 0; -const OUT_204: usize = 1; -fn aiur_fn_204( - inp: [G; IN_204], +const INPUT_SIZE_205: usize = 0; +const IN_205: usize = 0; +const OUT_205: usize = 1; +fn aiur_fn_205( + inp: [G; IN_205], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_204], ExecError> { +) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(15); let __v_1: G = G::from_u64(2); @@ -19974,21 +19993,21 @@ fn aiur_fn_204( let __v_30: G = G::from_u64(40); let __v_31: G = G::from_u64(217); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_204] = [__v_32]; - if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_205] = [__v_32]; + if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_205: usize = 0; -const IN_205: usize = 0; -const OUT_205: usize = 1; -fn aiur_fn_205( - inp: [G; IN_205], +const INPUT_SIZE_206: usize = 0; +const IN_206: usize = 0; +const OUT_206: usize = 1; +fn aiur_fn_206( + inp: [G; IN_206], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_205], ExecError> { +) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(9); let __v_1: G = G::from_u64(238); @@ -20023,21 +20042,21 @@ fn aiur_fn_205( let __v_30: G = G::from_u64(141); let __v_31: G = G::from_u64(52); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_205] = [__v_32]; - if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_206] = [__v_32]; + if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_206: usize = 0; -const IN_206: usize = 0; -const OUT_206: usize = 1; -fn aiur_fn_206( - inp: [G; IN_206], +const INPUT_SIZE_207: usize = 0; +const IN_207: usize = 0; +const OUT_207: usize = 1; +fn aiur_fn_207( + inp: [G; IN_207], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_206], ExecError> { +) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(37); let __v_1: G = G::from_u64(138); @@ -20072,21 +20091,21 @@ fn aiur_fn_206( let __v_30: G = G::from_u64(202); let __v_31: G = G::from_u64(62); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_206] = [__v_32]; - if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_207] = [__v_32]; + if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_207: usize = 0; -const IN_207: usize = 0; -const OUT_207: usize = 1; -fn aiur_fn_207( - inp: [G; IN_207], +const INPUT_SIZE_208: usize = 0; +const IN_208: usize = 0; +const OUT_208: usize = 1; +fn aiur_fn_208( + inp: [G; IN_208], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_207], ExecError> { +) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(119); let __v_1: G = G::from_u64(213); @@ -20121,21 +20140,21 @@ fn aiur_fn_207( let __v_30: G = G::from_u64(2); let __v_31: G = G::from_u64(160); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_207] = [__v_32]; - if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_208] = [__v_32]; + if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_208: usize = 0; -const IN_208: usize = 0; -const OUT_208: usize = 1; -fn aiur_fn_208( - inp: [G; IN_208], +const INPUT_SIZE_209: usize = 0; +const IN_209: usize = 0; +const OUT_209: usize = 1; +fn aiur_fn_209( + inp: [G; IN_209], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_208], ExecError> { +) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(32); let __v_1: G = G::from_u64(59); @@ -20170,21 +20189,21 @@ fn aiur_fn_208( let __v_30: G = G::from_u64(110); let __v_31: G = G::from_u64(238); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_208] = [__v_32]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_209] = [__v_32]; + if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_209: usize = 0; -const IN_209: usize = 0; -const OUT_209: usize = 1; -fn aiur_fn_209( - inp: [G; IN_209], +const INPUT_SIZE_210: usize = 0; +const IN_210: usize = 0; +const OUT_210: usize = 1; +fn aiur_fn_210( + inp: [G; IN_210], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_209], ExecError> { +) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(84); let __v_1: G = G::from_u64(139); @@ -20219,21 +20238,21 @@ fn aiur_fn_209( let __v_30: G = G::from_u64(29); let __v_31: G = G::from_u64(101); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_209] = [__v_32]; - if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_210] = [__v_32]; + if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_210: usize = 0; -const IN_210: usize = 0; -const OUT_210: usize = 1; -fn aiur_fn_210( - inp: [G; IN_210], +const INPUT_SIZE_211: usize = 0; +const IN_211: usize = 0; +const OUT_211: usize = 1; +fn aiur_fn_211( + inp: [G; IN_211], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_210], ExecError> { +) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(239); let __v_1: G = G::from_u64(78); @@ -20268,21 +20287,21 @@ fn aiur_fn_210( let __v_30: G = G::from_u64(253); let __v_31: G = G::from_u64(201); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_210] = [__v_32]; - if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_211] = [__v_32]; + if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_211: usize = 0; -const IN_211: usize = 0; -const OUT_211: usize = 1; -fn aiur_fn_211( - inp: [G; IN_211], +const INPUT_SIZE_212: usize = 0; +const IN_212: usize = 0; +const OUT_212: usize = 1; +fn aiur_fn_212( + inp: [G; IN_212], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_211], ExecError> { +) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(135); let __v_1: G = G::from_u64(9); @@ -20317,21 +20336,21 @@ fn aiur_fn_211( let __v_30: G = G::from_u64(12); let __v_31: G = G::from_u64(41); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_211] = [__v_32]; - if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_212] = [__v_32]; + if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_212: usize = 0; -const IN_212: usize = 0; -const OUT_212: usize = 1; -fn aiur_fn_212( - inp: [G; IN_212], +const INPUT_SIZE_213: usize = 0; +const IN_213: usize = 0; +const OUT_213: usize = 1; +fn aiur_fn_213( + inp: [G; IN_213], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_212], ExecError> { +) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(13); let __v_1: G = G::from_u64(35); @@ -20366,21 +20385,21 @@ fn aiur_fn_212( let __v_30: G = G::from_u64(226); let __v_31: G = G::from_u64(34); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_212] = [__v_32]; - if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_213] = [__v_32]; + if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_213: usize = 0; -const IN_213: usize = 0; -const OUT_213: usize = 1; -fn aiur_fn_213( - inp: [G; IN_213], +const INPUT_SIZE_214: usize = 0; +const IN_214: usize = 0; +const OUT_214: usize = 1; +fn aiur_fn_214( + inp: [G; IN_214], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_213], ExecError> { +) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(20); let __v_1: G = G::from_u64(207); @@ -20415,21 +20434,21 @@ fn aiur_fn_213( let __v_30: G = G::from_u64(229); let __v_31: G = G::from_u64(107); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_213] = [__v_32]; - if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_214] = [__v_32]; + if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_214: usize = 0; -const IN_214: usize = 0; -const OUT_214: usize = 1; -fn aiur_fn_214( - inp: [G; IN_214], +const INPUT_SIZE_215: usize = 0; +const IN_215: usize = 0; +const OUT_215: usize = 1; +fn aiur_fn_215( + inp: [G; IN_215], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_214], ExecError> { +) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(253); let __v_1: G = G::from_u64(83); @@ -20464,110 +20483,110 @@ fn aiur_fn_214( let __v_30: G = G::from_u64(101); let __v_31: G = G::from_u64(135); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_214] = [__v_32]; - if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_215] = [__v_32]; + 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_215: usize = 1; -const IN_215: usize = 1; -const OUT_215: usize = 1; -fn aiur_fn_215( - inp: [G; IN_215], +const INPUT_SIZE_216: usize = 1; +const IN_216: usize = 1; +const OUT_216: usize = 1; +fn aiur_fn_216( + inp: [G; IN_216], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_215], ExecError> { +) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; 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_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_215] = [__v_3]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_3]; + if 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 __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; 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_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_215] = [__v_5]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_5]; + if 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 __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_215] = [__v_7]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_7]; + if 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 __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; 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 __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_215] = [__v_9]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_9]; + if 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 __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_215] = [__v_11]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_11]; + if 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 __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_215] = [__v_13]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_13]; + if 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 __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_215] = [__v_15]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_15]; + if 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 __v_15: G = G::from_u64(0); - let __ret: [G; OUT_215] = [__v_15]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_15]; + if 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); }, } @@ -20586,24 +20605,24 @@ fn aiur_fn_215( }) } -const INPUT_SIZE_216: usize = 3; -const IN_216: usize = 3; -const OUT_216: usize = 2; -fn aiur_fn_216( - inp: [G; IN_216], +const INPUT_SIZE_217: usize = 3; +const IN_217: usize = 3; +const OUT_217: usize = 2; +fn aiur_fn_217( + inp: [G; IN_217], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_216], ExecError> { +) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; 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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { @@ -20612,7 +20631,7 @@ fn aiur_fn_216( let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_2]; let __cu = unconstrained; 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 = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -20622,8 +20641,8 @@ fn aiur_fn_216( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -20632,8 +20651,8 @@ fn aiur_fn_216( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20647,16 +20666,16 @@ fn aiur_fn_216( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_6, __v_10]; + 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); }, } }, _ => { - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; 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]; match __v_7.as_canonical_u64() { 1u64 => { @@ -20669,8 +20688,8 @@ fn aiur_fn_216( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20688,15 +20707,15 @@ fn aiur_fn_216( 1u64 => { let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_16]; let __cu = unconstrained; 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 = G::from_u64(1); let __v_19: G = G::from_u64(7); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_18, __v_22]; + 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); }, _ => { @@ -20705,8 +20724,8 @@ fn aiur_fn_216( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_16, __v_20]; + 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); }, } @@ -20717,8 +20736,8 @@ fn aiur_fn_216( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_16, __v_20]; + 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); }, } @@ -20726,65 +20745,65 @@ fn aiur_fn_216( } }, _ => { - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; 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 __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_216] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_10, __v_11]; + if 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); }, _ => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __cu = unconstrained; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_216] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_12, __v_13]; + if 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); }, _ => { - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; 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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __cu = unconstrained; 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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_1]; let __cu = unconstrained; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_216] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_14, __v_15]; + if 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); }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; 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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_14]; let __cu = unconstrained; 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_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_521(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_216] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_16, __v_17]; + if 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); }, _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; 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_16: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __cu = unconstrained; 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_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { @@ -20797,8 +20816,8 @@ fn aiur_fn_216( let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_20, __v_24]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_20, __v_24]; + 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); }, _ => { @@ -20833,8 +20852,8 @@ fn aiur_fn_216( let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_33, __v_37]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_33, __v_37]; + 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); }, _ => { @@ -20843,8 +20862,8 @@ fn aiur_fn_216( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_32, __v_36]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_32, __v_36]; + 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); }, } @@ -20855,8 +20874,8 @@ fn aiur_fn_216( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_32, __v_36]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_32, __v_36]; + 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); }, } @@ -20867,8 +20886,8 @@ fn aiur_fn_216( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_28, __v_32]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_28, __v_32]; + 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); }, } @@ -20879,8 +20898,8 @@ fn aiur_fn_216( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_28, __v_32]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_28, __v_32]; + 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); }, } @@ -20893,8 +20912,8 @@ fn aiur_fn_216( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_18, __v_22]; + 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); }, } @@ -20913,15 +20932,15 @@ fn aiur_fn_216( }) } -const INPUT_SIZE_217: usize = 1; -const IN_217: usize = 1; -const OUT_217: usize = 2; -fn aiur_fn_217( - inp: [G; IN_217], +const INPUT_SIZE_218: usize = 1; +const IN_218: usize = 1; +const OUT_218: usize = 2; +fn aiur_fn_218( + inp: [G; IN_218], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_217], ExecError> { +) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; @@ -20935,8 +20954,8 @@ fn aiur_fn_217( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20952,16 +20971,16 @@ fn aiur_fn_217( 7u64 => { match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_8]; let __cu = unconstrained; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_10]; let __cu = unconstrained; 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 = G::from_u64(7); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_16: G = G::from_u64(2); - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; 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_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); @@ -20972,8 +20991,8 @@ fn aiur_fn_217( let __v_24: G = G::from_u64(3); let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_23, __v_26]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_23, __v_26]; + 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); }, _ => { @@ -20982,8 +21001,8 @@ fn aiur_fn_217( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20994,8 +21013,8 @@ fn aiur_fn_217( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21004,15 +21023,15 @@ fn aiur_fn_217( }) } -const INPUT_SIZE_218: usize = 1; -const IN_218: usize = 1; -const OUT_218: usize = 2; -fn aiur_fn_218( - inp: [G; IN_218], +const INPUT_SIZE_219: usize = 1; +const IN_219: usize = 1; +const OUT_219: usize = 2; +fn aiur_fn_219( + inp: [G; IN_219], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_218], ExecError> { +) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; @@ -21026,8 +21045,8 @@ fn aiur_fn_218( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_218] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_4, __v_8]; + 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); }, _ => { @@ -21051,15 +21070,15 @@ fn aiur_fn_218( 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(2); - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; 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_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_218] = [__v_13, __v_20]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_13, __v_20]; + 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); }, _ => { @@ -21068,8 +21087,8 @@ fn aiur_fn_218( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_218] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_13, __v_17]; + 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); }, } @@ -21080,8 +21099,8 @@ fn aiur_fn_218( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_218] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_10, __v_14]; + 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); }, } @@ -21092,8 +21111,8 @@ fn aiur_fn_218( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_218] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_10, __v_14]; + 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); }, } @@ -21102,15 +21121,15 @@ fn aiur_fn_218( }) } -const INPUT_SIZE_219: usize = 1; -const IN_219: usize = 1; -const OUT_219: usize = 0; -fn aiur_fn_219( - inp: [G; IN_219], +const INPUT_SIZE_220: usize = 1; +const IN_220: usize = 1; +const OUT_220: usize = 0; +fn aiur_fn_220( + inp: [G; IN_220], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_219], ExecError> { +) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -21119,17 +21138,17 @@ fn aiur_fn_219( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_219] = []; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = []; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_2, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_219] = []; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_5]; let __cu = unconstrained; 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 __ret: [G; OUT_220] = []; + 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); }, _ => { @@ -21139,35 +21158,35 @@ fn aiur_fn_219( }) } -const INPUT_SIZE_220: usize = 1; -const IN_220: usize = 1; -const OUT_220: usize = 1; -fn aiur_fn_220( - inp: [G; IN_220], +const INPUT_SIZE_221: usize = 1; +const IN_221: usize = 1; +const OUT_221: usize = 1; +fn aiur_fn_221( + inp: [G; IN_221], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_220], ExecError> { +) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(65); - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; - let __ret: [G; OUT_220] = [__v_2]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_221] = [__v_2]; + if 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_221: usize = 2; -const IN_221: usize = 2; -const OUT_221: usize = 1; -fn aiur_fn_221( - inp: [G; IN_221], +const INPUT_SIZE_222: usize = 2; +const IN_222: usize = 2; +const OUT_222: usize = 1; +fn aiur_fn_222( + inp: [G; IN_222], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_221], ExecError> { +) -> Result<[G; OUT_222], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21177,18 +21196,18 @@ fn aiur_fn_221( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_221] = [__v_1]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_1]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_3, __v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_6, __v_5]; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_221] = [__v_7]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_7]; + if 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); }, _ => { @@ -21198,15 +21217,15 @@ fn aiur_fn_221( }) } -const INPUT_SIZE_222: usize = 1; -const IN_222: usize = 1; -const OUT_222: usize = 1; -fn aiur_fn_222( - inp: [G; IN_222], +const INPUT_SIZE_223: usize = 1; +const IN_223: usize = 1; +const OUT_223: usize = 1; +fn aiur_fn_223( + inp: [G; IN_223], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_222], ExecError> { +) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(128); @@ -21219,8 +21238,8 @@ fn aiur_fn_222( 1u64 => { let __v_5: G = G::from_u64(128); let __v_6: G = (__v_0 - __v_5); - let __ret: [G; OUT_222] = [__v_6]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_223] = [__v_6]; + if 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); }, _ => { @@ -21235,15 +21254,15 @@ fn aiur_fn_222( }) } -const INPUT_SIZE_223: usize = 2; -const IN_223: usize = 2; -const OUT_223: usize = 2; -fn aiur_fn_223( - inp: [G; IN_223], +const INPUT_SIZE_224: usize = 2; +const IN_224: usize = 2; +const OUT_224: usize = 2; +fn aiur_fn_224( + inp: [G; IN_224], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_223], ExecError> { +) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21251,8 +21270,8 @@ fn aiur_fn_223( let __v_3: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_2) } else { bytes2_less_than_value(__v_0, __v_2, record) }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_223] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_224] = [__v_0, __v_1]; + if 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); }, _ => { @@ -21274,11 +21293,11 @@ fn aiur_fn_223( let __v_12: G = (__v_0 - __v_11); let __v_13: G = G::from_u64(64); let __v_14: G = (__v_12 * __v_13); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_9]; let __cu = unconstrained; 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_15: G = __r_arr[0]; let __v_16: G = (__v_14 + __v_15); - let __ret: [G; OUT_223] = [__v_16, __v_10]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_224] = [__v_16, __v_10]; + if 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); }, _ => { @@ -21307,11 +21326,11 @@ fn aiur_fn_223( let __v_17: G = (__v_0 - __v_16); let __v_18: G = G::from_u64(4096); let __v_19: G = (__v_17 * __v_18); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_11]; let __cu = unconstrained; 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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(64); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_14]; let __cu = unconstrained; 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_23: G = __r_arr[0]; let __v_24: G = (__v_22 + __v_23); let __v_25: G = (__v_19 + __v_24); @@ -21319,8 +21338,8 @@ fn aiur_fn_223( let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_27.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_223] = [__v_25, __v_15]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_224] = [__v_25, __v_15]; + if 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); }, _ => { @@ -21361,15 +21380,15 @@ fn aiur_fn_223( let __v_20: G = (__v_0 - __v_19); let __v_21: G = G::from_u64(262144); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_11]; let __cu = unconstrained; 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_23: G = __r_arr[0]; let __v_24: G = G::from_u64(4096); let __v_25: G = (__v_23 * __v_24); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_14]; let __cu = unconstrained; 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_26: G = __r_arr[0]; let __v_27: G = G::from_u64(64); let __v_28: G = (__v_26 * __v_27); - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_17]; let __cu = unconstrained; 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_29: G = __r_arr[0]; let __v_30: G = (__v_28 + __v_29); let __v_31: G = (__v_25 + __v_30); @@ -21378,8 +21397,8 @@ fn aiur_fn_223( let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_34.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_223] = [__v_32, __v_18]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_224] = [__v_32, __v_18]; + if 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); }, _ => { @@ -21415,15 +21434,15 @@ fn aiur_fn_223( }) } -const INPUT_SIZE_224: usize = 1; -const IN_224: usize = 1; -const OUT_224: usize = 1; -fn aiur_fn_224( - inp: [G; IN_224], +const INPUT_SIZE_225: usize = 1; +const IN_225: usize = 1; +const OUT_225: usize = 1; +fn aiur_fn_225( + inp: [G; IN_225], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_224], ExecError> { +) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -21435,17 +21454,17 @@ fn aiur_fn_224( let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(2); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; 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 __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); @@ -21453,7 +21472,7 @@ fn aiur_fn_224( let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; 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_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); @@ -21461,7 +21480,7 @@ fn aiur_fn_224( let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(2); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; 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_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); @@ -21474,26 +21493,26 @@ fn aiur_fn_224( let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_40, __v_43, __v_30]; 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_44: G = __r_arr[0]; let __v_45: G = G::from_u64(3); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_224] = [__v_47]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_225] = [__v_47]; + 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_225: usize = 4; -const IN_225: usize = 4; -const OUT_225: usize = 1; -fn aiur_fn_225( - inp: [G; IN_225], +const INPUT_SIZE_226: usize = 4; +const IN_226: usize = 4; +const OUT_226: usize = 1; +fn aiur_fn_226( + inp: [G; IN_226], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_225], ExecError> { +) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21505,15 +21524,15 @@ fn aiur_fn_225( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_225] = [__v_1]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_226] = [__v_1]; + if 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); }, 0u64 => { - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5, __v_6]; let __cu = unconstrained; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7]; let __cu = unconstrained; 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_9: G = __r_arr[0]; let __v_10: G = G::from_u64(7); let __v_11: G = G::from_u64(0); @@ -21525,13 +21544,13 @@ fn aiur_fn_225( let __v_17: G = G::from_u64(3); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_8, __v_1, __v_2, __v_3]; 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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_225] = [__v_23]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_226] = [__v_23]; + 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); }, _ => { @@ -21541,15 +21560,15 @@ fn aiur_fn_225( }) } -const INPUT_SIZE_226: usize = 2; -const IN_226: usize = 2; -const OUT_226: usize = 1; -fn aiur_fn_226( - inp: [G; IN_226], +const INPUT_SIZE_227: usize = 2; +const IN_227: usize = 2; +const OUT_227: usize = 1; +fn aiur_fn_227( + inp: [G; IN_227], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_226], ExecError> { +) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21567,7 +21586,7 @@ fn aiur_fn_226( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -21587,7 +21606,7 @@ fn aiur_fn_226( let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -21601,8 +21620,8 @@ fn aiur_fn_226( let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_226] = [__v_33]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_33]; + if 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); }, _ => { @@ -21611,44 +21630,44 @@ fn aiur_fn_226( let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_226] = [__v_34]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_34]; + if 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); }, } }, _ => { - let __ret: [G; OUT_226] = [__v_0]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_0]; + if 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); }, } }, _ => { - let __ret: [G; OUT_226] = [__v_0]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_0]; + if 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); }, } }, _ => { - let __ret: [G; OUT_226] = [__v_0]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_0]; + if 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_227: usize = 2; -const IN_227: usize = 2; -const OUT_227: usize = 1; -fn aiur_fn_227( - inp: [G; IN_227], +const INPUT_SIZE_228: usize = 2; +const IN_228: usize = 2; +const OUT_228: usize = 1; +fn aiur_fn_228( + inp: [G; IN_228], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_227], ExecError> { +) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21661,75 +21680,75 @@ fn aiur_fn_227( 7u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_4]; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_1]; let __cu = unconstrained; 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 __v_7: G = __r_arr[0]; - let __ret: [G; OUT_227] = [__v_7]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_228] = [__v_7]; + if 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); }, _ => { - let __ret: [G; OUT_227] = [__v_0]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_228] = [__v_0]; + if 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); }, } }, _ => { - let __ret: [G; OUT_227] = [__v_0]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_228] = [__v_0]; + if 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_228: usize = 1; -const IN_228: usize = 1; -const OUT_228: usize = 4; -fn aiur_fn_228( - inp: [G; IN_228], +const INPUT_SIZE_229: usize = 1; +const IN_229: usize = 1; +const OUT_229: usize = 4; +fn aiur_fn_229( + inp: [G; IN_229], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_228], ExecError> { +) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_6, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_9, __v_10]; let __cu = unconstrained; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_228] = [__v_2, __v_5, __v_8, __v_11]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_229] = [__v_2, __v_5, __v_8, __v_11]; + if 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_229: usize = 1; -const IN_229: usize = 1; -const OUT_229: usize = 1; -fn aiur_fn_229( - inp: [G; IN_229], +const INPUT_SIZE_230: usize = 1; +const IN_230: usize = 1; +const OUT_230: usize = 1; +fn aiur_fn_230( + inp: [G; IN_230], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_229], ExecError> { +) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0]; let __cu = true; 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 { let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -21763,29 +21782,29 @@ fn aiur_fn_229( let __v_28: G = G::from_u64(1); let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_30]; 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_31: G = __r_arr[0]; - let __ret: [G; OUT_229] = [__v_31]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_31]; + if 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); }) } -const INPUT_SIZE_230: usize = 2; -const IN_230: usize = 2; -const OUT_230: usize = 2; -fn aiur_fn_230( - inp: [G; IN_230], +const INPUT_SIZE_231: usize = 2; +const IN_231: usize = 2; +const OUT_231: usize = 2; +fn aiur_fn_231( + inp: [G; IN_231], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_230], ExecError> { +) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -21795,9 +21814,9 @@ fn aiur_fn_230( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { @@ -21809,8 +21828,8 @@ fn aiur_fn_230( let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_230] = [__v_12, __v_15]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_12, __v_15]; + 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); }, _ => { @@ -21818,16 +21837,16 @@ fn aiur_fn_230( let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_230] = [__v_12, __v_15]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_12, __v_15]; + 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); }, } }, _ => { - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { @@ -21835,8 +21854,8 @@ fn aiur_fn_230( let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_230] = [__v_13, __v_16]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_13, __v_16]; + 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); }, _ => { @@ -21847,7 +21866,7 @@ fn aiur_fn_230( let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_15, __v_1]; let __cu = unconstrained; 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() { @@ -21856,30 +21875,30 @@ fn aiur_fn_230( let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_230] = [__v_18, __v_21]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_18, __v_21]; + 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); }, 1u64 => { let __v_18: G = G::from_u64(2); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_19, __v_1]; let __cu = unconstrained; 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 __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_230] = [__v_22, __v_21]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_22, __v_21]; + if 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); }, 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_17, __v_21]; let __cu = unconstrained; 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_23: G = __r_arr[0]; - let __ret: [G; OUT_230] = [__v_22, __v_23]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_22, __v_23]; + if 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); }, _ => { @@ -21897,8 +21916,8 @@ fn aiur_fn_230( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_230] = [__v_14, __v_17]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_14, __v_17]; + 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); }, } @@ -21912,59 +21931,59 @@ fn aiur_fn_230( let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_230] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_9, __v_12]; + 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); }, } }) } -const INPUT_SIZE_231: usize = 2; -const IN_231: usize = 2; -const OUT_231: usize = 2; -fn aiur_fn_231( - inp: [G; IN_231], +const INPUT_SIZE_232: usize = 2; +const IN_232: usize = 2; +const OUT_232: usize = 2; +fn aiur_fn_232( + inp: [G; IN_232], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_231], ExecError> { +) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_231] = [__v_4, __v_3]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_232] = [__v_4, __v_3]; + if 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); }, _ => { let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4]; let __cu = unconstrained; 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]; - let __ret: [G; OUT_231] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_232] = [__v_5, __v_6]; + if 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); }, } }) } -const INPUT_SIZE_232: usize = 1; -const IN_232: usize = 1; -const OUT_232: usize = 2; -fn aiur_fn_232( - inp: [G; IN_232], +const INPUT_SIZE_233: usize = 1; +const IN_233: usize = 1; +const OUT_233: usize = 2; +fn aiur_fn_233( + inp: [G; IN_233], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_232], ExecError> { +) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -21981,16 +22000,16 @@ fn aiur_fn_232( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_232] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_11, __v_12]; + if 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); }, _ => { @@ -22003,18 +22022,18 @@ fn aiur_fn_232( 7u64 => { match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_13]; let __cu = unconstrained; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_232] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_15, __v_16]; + if 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); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_232] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_15, __v_16]; + if 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); }, } @@ -22022,8 +22041,8 @@ fn aiur_fn_232( _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_232] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_15, __v_16]; + if 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); }, } @@ -22033,8 +22052,8 @@ fn aiur_fn_232( _ => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_232] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_9, __v_10]; + if 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); }, } @@ -22042,23 +22061,23 @@ fn aiur_fn_232( _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_232] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_5, __v_6]; + if 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); }, } }) } -const INPUT_SIZE_233: usize = 1; -const IN_233: usize = 1; -const OUT_233: usize = 2; -fn aiur_fn_233( - inp: [G; IN_233], +const INPUT_SIZE_234: usize = 1; +const IN_234: usize = 1; +const OUT_234: usize = 2; +fn aiur_fn_234( + inp: [G; IN_234], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_233], ExecError> { +) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -22096,8 +22115,8 @@ fn aiur_fn_233( 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_233] = [__v_26, __v_27]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_26, __v_27]; + if 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); }, _ => { @@ -22112,8 +22131,8 @@ fn aiur_fn_233( match __v_33.as_canonical_u64() { 1u64 => { let __v_34: G = G::from_u64(1); - let __ret: [G; OUT_233] = [__v_34, __v_31]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_34, __v_31]; + if 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); }, _ => { @@ -22123,8 +22142,8 @@ fn aiur_fn_233( 0u64 => { let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_233] = [__v_36, __v_37]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_36, __v_37]; + if 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); }, _ => { @@ -22133,15 +22152,15 @@ fn aiur_fn_233( match __v_37.as_canonical_u64() { 1u64 => { let __v_38: G = G::from_u64(1); - let __ret: [G; OUT_233] = [__v_38, __v_31]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_38, __v_31]; + if 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); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_233] = [__v_38, __v_39]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_38, __v_39]; + if 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); }, } @@ -22155,8 +22174,8 @@ fn aiur_fn_233( _ => { let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_233] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_21, __v_22]; + if 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); }, } @@ -22164,23 +22183,23 @@ fn aiur_fn_233( _ => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_233] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_11, __v_12]; + if 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); }, } }) } -const INPUT_SIZE_234: usize = 2; -const IN_234: usize = 2; -const OUT_234: usize = 2; -fn aiur_fn_234( - inp: [G; IN_234], +const INPUT_SIZE_235: usize = 2; +const IN_235: usize = 2; +const OUT_235: usize = 2; +fn aiur_fn_235( + inp: [G; IN_235], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_234], ExecError> { +) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -22188,8 +22207,8 @@ fn aiur_fn_234( let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_234] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_235] = [__v_0, __v_1]; + if 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); }, _ => { @@ -22197,59 +22216,59 @@ fn aiur_fn_234( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_5, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_234] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_235] = [__v_8, __v_9]; + if 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); }, } }) } -const INPUT_SIZE_235: usize = 1; -const IN_235: usize = 1; -const OUT_235: usize = 4; -fn aiur_fn_235( - inp: [G; IN_235], +const INPUT_SIZE_236: usize = 1; +const IN_236: usize = 1; +const OUT_236: usize = 4; +fn aiur_fn_236( + inp: [G; IN_236], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_235], ExecError> { +) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_3, __v_4]; let __cu = unconstrained; 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 = __r_arr[1]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_6, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_235] = [__v_2, __v_5, __v_8, __v_9]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_2, __v_5, __v_8, __v_9]; + if 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); }) } -const INPUT_SIZE_236: usize = 2; -const IN_236: usize = 2; -const OUT_236: usize = 1; -fn aiur_fn_236( - inp: [G; IN_236], +const INPUT_SIZE_237: usize = 2; +const IN_237: usize = 2; +const OUT_237: usize = 1; +fn aiur_fn_237( + inp: [G; IN_237], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_236], ExecError> { +) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0]; let __cu = true; 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 { 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -22304,8 +22323,8 @@ fn aiur_fn_236( 1u64 => { let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_236] = [__v_38]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_38]; + 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); }, _ => { @@ -22321,8 +22340,8 @@ fn aiur_fn_236( let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_236] = [__v_46]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_46]; + 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); }, _ => { @@ -22342,8 +22361,8 @@ fn aiur_fn_236( let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_236] = [__v_52]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_52]; + 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); }, _ => { @@ -22363,8 +22382,8 @@ fn aiur_fn_236( let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_236] = [__v_56]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_56]; + 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); }, } @@ -22375,212 +22394,212 @@ fn aiur_fn_236( }) } -const INPUT_SIZE_237: usize = 1; -const IN_237: usize = 1; -const OUT_237: usize = 1; -fn aiur_fn_237( - inp: [G; IN_237], +const INPUT_SIZE_238: usize = 1; +const IN_238: usize = 1; +const OUT_238: usize = 1; +fn aiur_fn_238( + inp: [G; IN_238], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_237], ExecError> { +) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; 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_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_3]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_3]; + if 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 __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; 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_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_5]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_5]; + if 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 __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_7]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_7]; + if 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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_9]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_9]; + if 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 __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_11]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_11]; + if 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 __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_13]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_13]; + if 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 __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_15]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_15]; + if 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 __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_17]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_17]; + if 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 __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_19]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_19]; + if 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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_21]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_21]; + if 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 __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; 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_21: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; 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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_23]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_23]; + if 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 __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; 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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_25]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_25]; + if 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 __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_27]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_27]; + if 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 __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; 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_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_29]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_29]; + if 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 __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; 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_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_31]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_31]; + if 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 __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; 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_31: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __cu = unconstrained; 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_32: G = __r_arr[0]; match __v_32.as_canonical_u64() { 1u64 => { let __v_33: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_33]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_33]; + if 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_33: G = G::from_u64(0); - let __ret: [G; OUT_237] = [__v_33]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_33]; + if 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); }, } @@ -22617,56 +22636,56 @@ fn aiur_fn_237( }) } -const INPUT_SIZE_238: usize = 1; -const IN_238: usize = 1; -const OUT_238: usize = 1; -fn aiur_fn_238( - inp: [G; IN_238], +const INPUT_SIZE_239: usize = 1; +const IN_239: usize = 1; +const OUT_239: usize = 1; +fn aiur_fn_239( + inp: [G; IN_239], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_238], ExecError> { +) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; 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_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; 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_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; 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_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; 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_16: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; 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_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; let __v_21: G = (__v_18 + __v_20); let __v_22: G = (__v_16 + __v_21); @@ -22677,21 +22696,21 @@ fn aiur_fn_238( let __v_27: G = (__v_6 + __v_26); let __v_28: G = (__v_4 + __v_27); let __v_29: G = (__v_2 + __v_28); - let __ret: [G; OUT_238] = [__v_29]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_239] = [__v_29]; + if 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); }) } -const INPUT_SIZE_239: usize = 1; -const IN_239: usize = 1; -const OUT_239: usize = 2; -fn aiur_fn_239( - inp: [G; IN_239], +const INPUT_SIZE_240: usize = 1; +const IN_240: usize = 1; +const OUT_240: usize = 2; +fn aiur_fn_240( + inp: [G; IN_240], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_239], ExecError> { +) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -22704,8 +22723,8 @@ fn aiur_fn_239( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_239] = [__v_5, __v_3]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_5, __v_3]; + if 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); }, _ => { @@ -22713,16 +22732,16 @@ fn aiur_fn_239( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_239] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_5, __v_8]; + 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); }, } }, 2u64 => { - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -22730,8 +22749,8 @@ fn aiur_fn_239( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_239] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_7, __v_10]; + 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); }, _ => { @@ -22739,18 +22758,18 @@ fn aiur_fn_239( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_239] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_7, __v_10]; + 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); }, } }, 3u64 => { - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2, __v_3]; let __cu = unconstrained; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_239] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_5, __v_6]; + if 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); }, _ => { @@ -22758,23 +22777,23 @@ fn aiur_fn_239( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_239] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_5, __v_8]; + 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); }, } }) } -const INPUT_SIZE_240: usize = 2; -const IN_240: usize = 2; -const OUT_240: usize = 2; -fn aiur_fn_240( - inp: [G; IN_240], +const INPUT_SIZE_241: usize = 2; +const IN_241: usize = 2; +const OUT_241: usize = 2; +fn aiur_fn_241( + inp: [G; IN_241], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_240], ExecError> { +) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -22785,22 +22804,22 @@ fn aiur_fn_240( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; 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]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_1]; let __cu = unconstrained; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9]; let __cu = unconstrained; 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_11: G = __r_arr[0]; - let __ret: [G; OUT_240] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_10, __v_11]; + if 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); }, _ => { @@ -22808,8 +22827,8 @@ fn aiur_fn_240( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_10, __v_13]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_10, __v_13]; + 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); }, } @@ -22819,8 +22838,8 @@ fn aiur_fn_240( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_8, __v_11]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_8, __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); }, } @@ -22830,44 +22849,44 @@ fn aiur_fn_240( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_6, __v_9]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_6, __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); }, } }) } -const INPUT_SIZE_241: usize = 1; -const IN_241: usize = 1; -const OUT_241: usize = 1; -fn aiur_fn_241( - inp: [G; IN_241], +const INPUT_SIZE_242: usize = 1; +const IN_242: usize = 1; +const OUT_242: usize = 1; +fn aiur_fn_242( + inp: [G; IN_242], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_241], ExecError> { +) -> Result<[G; OUT_242], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(7); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_241] = [__v_4]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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); }) } -const INPUT_SIZE_242: usize = 1; -const IN_242: usize = 1; -const OUT_242: usize = 3; -fn aiur_fn_242( - inp: [G; IN_242], +const INPUT_SIZE_243: usize = 1; +const IN_243: usize = 1; +const OUT_243: usize = 3; +fn aiur_fn_243( + inp: [G; IN_243], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_242], ExecError> { +) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -22884,40 +22903,40 @@ fn aiur_fn_242( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_3]; let __cu = unconstrained; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10]; let __cu = unconstrained; 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_15: G = __r_arr[0]; - let __ret: [G; OUT_242] = [__v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_13, __v_14, __v_15]; + if 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); }, _ => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; 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_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; 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_17: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; - let __ret: [G; OUT_242] = [__v_15, __v_16, __v_18]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_15, __v_16, __v_18]; + if 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); }, _ => { @@ -22926,8 +22945,8 @@ fn aiur_fn_242( let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 10] = [__v_17, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_242] = [__v_15, __v_16, __v_19]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_15, __v_16, __v_19]; + 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); }, } @@ -22940,8 +22959,8 @@ fn aiur_fn_242( let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 10] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_242] = [__v_11, __v_12, __v_15]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_11, __v_12, __v_15]; + 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); }, } @@ -22952,8 +22971,8 @@ fn aiur_fn_242( let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_242] = [__v_9, __v_10, __v_13]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_9, __v_10, __v_13]; + 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); }, } @@ -22964,41 +22983,41 @@ fn aiur_fn_242( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_242] = [__v_5, __v_6, __v_9]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_243] = [__v_5, __v_6, __v_9]; + 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); }, } }) } -const INPUT_SIZE_243: usize = 2; -const IN_243: usize = 2; -const OUT_243: usize = 1; -fn aiur_fn_243( - inp: [G; IN_243], +const INPUT_SIZE_244: usize = 2; +const IN_244: usize = 2; +const OUT_244: usize = 1; +fn aiur_fn_244( + inp: [G; IN_244], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_243], ExecError> { +) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; 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_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); let __v_6: G = (__v_0 * __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; 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_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, @@ -23010,9 +23029,9 @@ fn aiur_fn_243( break '__mc_1 [__v_2]; }, _ => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2]; let __cu = unconstrained; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8]; let __cu = unconstrained; 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_9: G = __r_arr[0]; break '__mc_1 [__v_9]; }, @@ -23026,25 +23045,25 @@ fn aiur_fn_243( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_10, __v_7, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __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_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_9, __v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_18]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_244] = [__v_18]; + 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); }) } -const INPUT_SIZE_244: usize = 4; -const IN_244: usize = 4; -const OUT_244: usize = 1; -fn aiur_fn_244( - inp: [G; IN_244], +const INPUT_SIZE_245: usize = 4; +const IN_245: usize = 4; +const OUT_245: usize = 1; +fn aiur_fn_245( + inp: [G; IN_245], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_244], ExecError> { +) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23053,34 +23072,34 @@ fn aiur_fn_244( let __v_4: G = (__v_0 - __v_2); match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __v_3]; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __ret: [G; OUT_244] = [__v_6]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_245] = [__v_6]; + if 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 __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __v_3]; let __cu = unconstrained; 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]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_1]; let __cu = unconstrained; 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 __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_6]; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_244] = [__v_7]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_245] = [__v_7]; + if 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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_3]; let __cu = unconstrained; 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 __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_6]; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __ret: [G; OUT_244] = [__v_7]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_245] = [__v_7]; + if 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); }, } @@ -23089,54 +23108,54 @@ fn aiur_fn_244( }) } -const INPUT_SIZE_245: usize = 3; -const IN_245: usize = 3; -const OUT_245: usize = 1; -fn aiur_fn_245( - inp: [G; IN_245], +const INPUT_SIZE_246: usize = 3; +const IN_246: usize = 3; +const OUT_246: usize = 1; +fn aiur_fn_246( + inp: [G; IN_246], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_245], ExecError> { +) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_1]; let __cu = unconstrained; 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 __ret: [G; OUT_245] = [__v_4]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_4]; + if 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 __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; 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_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; let __cu = unconstrained; 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_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_4]; let __cu = unconstrained; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9, __v_10]; let __cu = unconstrained; 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_11: G = __r_arr[0]; - let __ret: [G; OUT_245] = [__v_11]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_11]; + if 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_9: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9, __v_4]; let __cu = unconstrained; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_245] = [__v_10]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_246] = [__v_10]; + if 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); }, } @@ -23145,21 +23164,21 @@ fn aiur_fn_245( }) } -const INPUT_SIZE_246: usize = 4; -const IN_246: usize = 4; -const OUT_246: usize = 1; -fn aiur_fn_246( - inp: [G; IN_246], +const INPUT_SIZE_247: usize = 4; +const IN_247: usize = 4; +const OUT_247: usize = 1; +fn aiur_fn_247( + inp: [G; IN_247], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_246], ExecError> { +) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { @@ -23167,25 +23186,25 @@ fn aiur_fn_246( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_5, __v_8]; 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_9: G = __r_arr[0]; - let __ret: [G; OUT_246] = [__v_9]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_247] = [__v_9]; + if 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 __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_6]; let __cu = unconstrained; 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_8: G = __r_arr[0]; let __v_9: G = (__v_7 - __v_8); let __v_10: G = (__v_0 * __v_9); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_5]; let __cu = unconstrained; 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_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -23201,54 +23220,54 @@ fn aiur_fn_246( let __v_15: G = (__v_2 - __v_14); let __v_16: G = (__v_0 + __v_15); let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_11]; let __cu = unconstrained; 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_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); let __v_20: G = (__v_16 * __v_19); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_20, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_20, __v_11]; let __cu = unconstrained; 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_21: G = __r_arr[0]; - let __ret: [G; OUT_246] = [__v_21]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_247] = [__v_21]; + if 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); }, } }) } -const INPUT_SIZE_247: usize = 3; -const IN_247: usize = 3; -const OUT_247: usize = 1; -fn aiur_fn_247( - inp: [G; IN_247], +const INPUT_SIZE_248: usize = 3; +const IN_248: usize = 3; +const OUT_248: usize = 1; +fn aiur_fn_248( + inp: [G; IN_248], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_247], ExecError> { +) -> Result<[G; OUT_248], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_1]; let __cu = unconstrained; 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 __ret: [G; OUT_247] = [__v_4]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_248] = [__v_4]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; 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_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; let __cu = unconstrained; 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_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_4]; let __cu = unconstrained; 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_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, @@ -23271,29 +23290,29 @@ fn aiur_fn_247( let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 10] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_23, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_23, __v_22]; let __cu = unconstrained; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_24, __v_9]; let __cu = unconstrained; 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_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(1); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_9]; let __cu = unconstrained; 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_27: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_26, __v_27]; let __cu = unconstrained; 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_28: G = __r_arr[0]; - let __ret: [G; OUT_247] = [__v_28]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_248] = [__v_28]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_26, __v_9]; let __cu = unconstrained; 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_27: G = __r_arr[0]; - let __ret: [G; OUT_247] = [__v_27]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_248] = [__v_27]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23302,20 +23321,20 @@ fn aiur_fn_247( }) } -const INPUT_SIZE_248: usize = 3; -const IN_248: usize = 3; -const OUT_248: usize = 1; -fn aiur_fn_248( - inp: [G; IN_248], +const INPUT_SIZE_249: usize = 3; +const IN_249: usize = 3; +const OUT_249: usize = 1; +fn aiur_fn_249( + inp: [G; IN_249], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_248], ExecError> { +) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { @@ -23323,23 +23342,23 @@ fn aiur_fn_248( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4, __v_7]; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_8]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_8]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; 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_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; let __cu = unconstrained; 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_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_4]; let __cu = unconstrained; 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_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, @@ -23349,16 +23368,16 @@ fn aiur_fn_248( } }; let __v_9: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; 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_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; let __cu = unconstrained; 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_12: G = __r_arr[0]; let __v_13: G = (__v_11 - __v_12); let __v_14: G = (__v_0 * __v_13); let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; 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_15: G = __r_arr[0]; break '__mc_1 [__v_15]; }, @@ -23369,7 +23388,7 @@ fn aiur_fn_248( }; let __v_15: G = __mc_out___mc_1[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_15]; let __cu = unconstrained; 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_17: G = __r_arr[0]; let __v_18: G = (__v_16 - __v_17); let __v_19: G = (__v_0 * __v_18); @@ -23386,18 +23405,18 @@ fn aiur_fn_248( let __v_30: G = G::from_u64(1); let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_33, __v_32]; let __cu = unconstrained; 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_34: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_34, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_34, __v_9]; let __cu = unconstrained; 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]; match __v_35.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19, __v_15]; let __cu = unconstrained; 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_36: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_36]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_36]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23415,10 +23434,10 @@ fn aiur_fn_248( let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 10] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_49: G = { let __values: [G; 10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_48]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19, __v_15, __v_36, __v_49]; 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_50: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_50]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_249] = [__v_50]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23427,15 +23446,15 @@ fn aiur_fn_248( }) } -const INPUT_SIZE_249: usize = 3; -const IN_249: usize = 3; -const OUT_249: usize = 2; -fn aiur_fn_249( - inp: [G; IN_249], +const INPUT_SIZE_250: usize = 3; +const IN_250: usize = 3; +const OUT_250: usize = 2; +fn aiur_fn_250( + inp: [G; IN_250], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_249], ExecError> { +) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23444,13 +23463,13 @@ fn aiur_fn_249( let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; let __v_9: G = (__v_6 + __v_8); match __v_9.as_canonical_u64() { @@ -23464,27 +23483,27 @@ fn aiur_fn_249( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_249] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; 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_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_16]; let __cu = unconstrained; 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_19: G = __r_arr[0]; break '__mc_0 [__v_19]; }, @@ -23492,11 +23511,11 @@ fn aiur_fn_249( let __v_19: G = G::from_u64(1); let __v_20: G = (__v_19 - __v_15); let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_21 - __v_22); let __v_24: G = (__v_20 * __v_23); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_24, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_24, __v_16]; let __cu = unconstrained; 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_25: G = __r_arr[0]; break '__mc_0 [__v_25]; }, @@ -23507,10 +23526,10 @@ fn aiur_fn_249( let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_249] = [__v_20, __v_23]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_20, __v_23]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23519,8 +23538,8 @@ fn aiur_fn_249( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_249] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23537,25 +23556,25 @@ fn aiur_fn_249( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_249] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_249] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23564,8 +23583,8 @@ fn aiur_fn_249( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_249] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_250] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23576,31 +23595,31 @@ fn aiur_fn_249( }) } -const INPUT_SIZE_250: usize = 4; -const IN_250: usize = 4; -const OUT_250: usize = 2; -fn aiur_fn_250( - inp: [G; IN_250], +const INPUT_SIZE_251: usize = 4; +const IN_251: usize = 4; +const OUT_251: usize = 2; +fn aiur_fn_251( + inp: [G; IN_251], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_250], ExecError> { +) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; 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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; 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 __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; 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_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = (__v_5 + __v_10); @@ -23609,29 +23628,29 @@ fn aiur_fn_250( let __v_12: G = G::from_u64(1); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; 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_16: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __cu = unconstrained; 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_17: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; break '__mc_0 [__v_18]; }, _ => { - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_18]; let __cu = unconstrained; 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_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; break '__mc_0 [__v_20]; }, @@ -23650,15 +23669,15 @@ fn aiur_fn_250( let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_15, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15, __v_32]; let __cu = unconstrained; 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_34: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_34]; let __cu = unconstrained; 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_35: G = __r_arr[0]; let __v_36: G = (__v_33 - __v_35); let __v_37: G = (__v_2 * __v_36); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3, __v_15]; let __cu = unconstrained; 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_38: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_37, __v_38]; let __cu = unconstrained; 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_39: G = __r_arr[0]; break '__mc_0 [__v_39]; }, @@ -23671,10 +23690,10 @@ fn aiur_fn_250( let __v_20: G = G::from_u64(2); let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_250] = [__v_19, __v_22]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_19, __v_22]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23683,8 +23702,8 @@ fn aiur_fn_250( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23693,44 +23712,44 @@ fn aiur_fn_250( let __v_12: G = G::from_u64(1); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; 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_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; 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_19: G = __r_arr[0]; break '__mc_1 [__v_19]; }, _ => { - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); let __v_22: G = (__v_21 - __v_15); let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; 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_24: G = __r_arr[0]; let __v_25: G = (__v_23 - __v_24); let __v_26: G = (__v_22 * __v_25); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; 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_27: G = __r_arr[0]; break '__mc_1 [__v_27]; }, _ => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; 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_21: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; 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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { @@ -23740,34 +23759,34 @@ fn aiur_fn_250( let __v_26: G = (__v_15 - __v_25); let __v_27: G = (__v_2 + __v_26); let __v_28: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; 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_29: G = __r_arr[0]; let __v_30: G = (__v_28 - __v_29); let __v_31: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = (__v_31 - __v_32); let __v_34: G = (__v_30 * __v_33); let __v_35: G = (__v_27 * __v_34); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_16]; let __cu = unconstrained; 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_36: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_35, __v_36]; let __cu = unconstrained; 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_37: G = __r_arr[0]; break '__mc_1 [__v_37]; }, _ => { - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; 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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; 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_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, _ => { - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; 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_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, @@ -23784,10 +23803,10 @@ fn aiur_fn_250( let __v_21: G = G::from_u64(2); let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_250] = [__v_20, __v_23]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_20, __v_23]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23796,8 +23815,8 @@ fn aiur_fn_250( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_251] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23806,15 +23825,15 @@ fn aiur_fn_250( }) } -const INPUT_SIZE_251: usize = 2; -const IN_251: usize = 2; -const OUT_251: usize = 1; -fn aiur_fn_251( - inp: [G; IN_251], +const INPUT_SIZE_252: usize = 2; +const IN_252: usize = 2; +const OUT_252: usize = 1; +fn aiur_fn_252( + inp: [G; IN_252], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_251], ExecError> { +) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23824,18 +23843,18 @@ fn aiur_fn_251( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_251] = [__v_0]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_0]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_251] = [__v_8]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_252] = [__v_8]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23845,264 +23864,264 @@ fn aiur_fn_251( }) } -const INPUT_SIZE_252: usize = 3; -const IN_252: usize = 3; -const OUT_252: usize = 2; -fn aiur_fn_252( - inp: [G; IN_252], +const INPUT_SIZE_253: usize = 3; +const IN_253: usize = 3; +const OUT_253: usize = 2; +fn aiur_fn_253( + inp: [G; IN_253], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_252], ExecError> { +) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; 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_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __v_2]; let __cu = unconstrained; 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]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_6]; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_2]; let __cu = unconstrained; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8]; let __cu = unconstrained; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_2]; let __cu = unconstrained; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10]; let __cu = unconstrained; 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; 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_12: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_11, __v_14]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_11, __v_14]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; 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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_14]; let __cu = unconstrained; 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_15: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_15]; let __cu = unconstrained; 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_16: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_13, __v_16]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_13, __v_16]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; 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_16: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_16]; let __cu = unconstrained; 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_17: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_15, __v_18]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_15, __v_18]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_17, __v_20]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_17, __v_20]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_1, __v_2]; let __cu = unconstrained; 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_20: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_20]; let __cu = unconstrained; 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_21: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; let __cu = unconstrained; 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 __ret: [G; OUT_252] = [__v_19, __v_22]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_19, __v_22]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_22]; let __cu = unconstrained; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_23]; let __cu = unconstrained; 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_24: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_21, __v_24]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_21, __v_24]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; 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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_24]; let __cu = unconstrained; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; let __cu = unconstrained; 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]; - let __ret: [G; OUT_252] = [__v_23, __v_26]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_23, __v_26]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; 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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; 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_26: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_26]; let __cu = unconstrained; 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_27: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_27]; let __cu = unconstrained; 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]; - let __ret: [G; OUT_252] = [__v_25, __v_28]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_25, __v_28]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __v_2]; let __cu = unconstrained; 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_28: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_28]; let __cu = unconstrained; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_29]; let __cu = unconstrained; 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_30: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_27, __v_30]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_27, __v_30]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; 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_27: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; 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_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_30]; let __cu = unconstrained; 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_31: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_29, __v_31]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_29, __v_31]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; 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_29: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; 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_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __v_2]; let __cu = unconstrained; 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_32: G = __r_arr[0]; - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_32]; let __cu = unconstrained; 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_33: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_31, __v_33]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_31, __v_33]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24111,8 +24130,8 @@ fn aiur_fn_252( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_252] = [__v_31, __v_35]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_253] = [__v_31, __v_35]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24145,15 +24164,15 @@ fn aiur_fn_252( }) } -const INPUT_SIZE_253: usize = 2; -const IN_253: usize = 2; -const OUT_253: usize = 3; -fn aiur_fn_253( - inp: [G; IN_253], +const INPUT_SIZE_254: usize = 2; +const IN_254: usize = 2; +const OUT_254: usize = 3; +fn aiur_fn_254( + inp: [G; IN_254], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_253], ExecError> { +) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24164,9 +24183,9 @@ fn aiur_fn_253( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; 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]; match __v_7.as_canonical_u64() { 0u64 => { @@ -24174,8 +24193,8 @@ fn aiur_fn_253( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_8, __v_0, __v_11]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_8, __v_0, __v_11]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24201,8 +24220,8 @@ fn aiur_fn_253( match __v_16.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_253] = [__v_19, __v_12, __v_17]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_19, __v_12, __v_17]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24210,8 +24229,8 @@ fn aiur_fn_253( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24221,8 +24240,8 @@ fn aiur_fn_253( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24232,8 +24251,8 @@ fn aiur_fn_253( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_11, __v_0, __v_14]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_11, __v_0, __v_14]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24245,23 +24264,23 @@ fn aiur_fn_253( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_6, __v_0, __v_9]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_254] = [__v_6, __v_0, __v_9]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_254: usize = 2; -const IN_254: usize = 2; -const OUT_254: usize = 1; -fn aiur_fn_254( - inp: [G; IN_254], +const INPUT_SIZE_255: usize = 2; +const IN_255: usize = 2; +const OUT_255: usize = 1; +fn aiur_fn_255( + inp: [G; IN_255], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_254], ExecError> { +) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24278,32 +24297,32 @@ fn aiur_fn_254( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_14]; 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_15: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15]; let __cu = unconstrained; 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_16: G = __r_arr[0]; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; 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_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; 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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(3); let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_254] = [__v_27]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_27]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; 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_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); @@ -24323,23 +24342,23 @@ fn aiur_fn_254( let __v_42: G = G::from_u64(3); let __v_43: G = G::from_u64(0); let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_254] = [__v_44]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_44]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_255: usize = 1; -const IN_255: usize = 1; -const OUT_255: usize = 1; -fn aiur_fn_255( - inp: [G; IN_255], +const INPUT_SIZE_256: usize = 1; +const IN_256: usize = 1; +const OUT_256: usize = 1; +fn aiur_fn_256( + inp: [G; IN_256], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_255], ExecError> { +) -> Result<[G; OUT_256], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -24349,12 +24368,12 @@ fn aiur_fn_255( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 7u64 => { - let __ret: [G; OUT_255] = [__v_0]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_0]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -24364,41 +24383,41 @@ fn aiur_fn_255( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14]; let __cu = unconstrained; 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_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_255] = [__v_0]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_0]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_16]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_16]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_255] = [__v_0]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_0]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_255] = [__v_0]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_0]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24407,33 +24426,33 @@ fn aiur_fn_255( }) } -const INPUT_SIZE_256: usize = 3; -const IN_256: usize = 3; -const OUT_256: usize = 2; -fn aiur_fn_256( - inp: [G; IN_256], +const INPUT_SIZE_257: usize = 3; +const IN_257: usize = 3; +const OUT_257: usize = 2; +fn aiur_fn_257( + inp: [G; IN_257], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_256], ExecError> { +) -> Result<[G; OUT_257], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; let __cu = unconstrained; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; 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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); @@ -24444,30 +24463,30 @@ fn aiur_fn_256( let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1]; 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_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_257: usize = 1; -const IN_257: usize = 1; -const OUT_257: usize = 1; -fn aiur_fn_257( - inp: [G; IN_257], +const INPUT_SIZE_258: usize = 1; +const IN_258: usize = 1; +const OUT_258: usize = 1; +fn aiur_fn_258( + inp: [G; IN_258], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_257], ExecError> { +) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -24484,7 +24503,7 @@ fn aiur_fn_257( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -24494,15 +24513,15 @@ fn aiur_fn_257( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; 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_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_15]; let __cu = unconstrained; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_257] = [__v_17]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_17]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24523,22 +24542,22 @@ fn aiur_fn_257( match __v_22.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_bool((__v_23 == G::ZERO)); - let __ret: [G; OUT_257] = [__v_26]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_26]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __ret: [G; OUT_257] = [__v_26]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_26]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_257] = [__v_20]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_20]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24547,39 +24566,39 @@ fn aiur_fn_257( }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_257] = [__v_15]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_15]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_257] = [__v_9]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_9]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_257] = [__v_5]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_5]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_258: usize = 5; -const IN_258: usize = 5; -const OUT_258: usize = 2; -fn aiur_fn_258( - inp: [G; IN_258], +const INPUT_SIZE_259: usize = 5; +const IN_259: usize = 5; +const OUT_259: usize = 2; +fn aiur_fn_259( + inp: [G; IN_259], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_258], ExecError> { +) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24595,14 +24614,14 @@ fn aiur_fn_258( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_258] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -24612,8 +24631,8 @@ fn aiur_fn_258( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_258] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -24622,7 +24641,7 @@ fn aiur_fn_258( let __v_12: G = (__v_10 + __v_11); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { @@ -24631,8 +24650,8 @@ fn aiur_fn_258( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_258] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24642,28 +24661,28 @@ fn aiur_fn_258( let __v_17: G = (__v_4 + __v_16); let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_15]; let __cu = unconstrained; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_20, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_20, __v_9]; let __cu = unconstrained; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_22]; let __cu = unconstrained; 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_23: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_258] = [__v_21, __v_24]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_21, __v_24]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_258] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24679,28 +24698,28 @@ fn aiur_fn_258( }) } -const INPUT_SIZE_259: usize = 3; -const IN_259: usize = 3; -const OUT_259: usize = 2; -fn aiur_fn_259( - inp: [G; IN_259], +const INPUT_SIZE_260: usize = 3; +const IN_260: usize = 3; +const OUT_260: usize = 2; +fn aiur_fn_260( + inp: [G; IN_260], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_259], ExecError> { +) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; 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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; 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]; match __v_7.as_canonical_u64() { 1u64 => { @@ -24713,15 +24732,15 @@ fn aiur_fn_259( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_259] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -24730,14 +24749,14 @@ fn aiur_fn_259( let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13]; let __cu = unconstrained; 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_17: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_259] = [__v_16, __v_19]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_16, __v_19]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24746,8 +24765,8 @@ fn aiur_fn_259( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_259] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24766,15 +24785,15 @@ fn aiur_fn_259( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_259] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -24783,16 +24802,16 @@ fn aiur_fn_259( let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_13]; let __cu = unconstrained; 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_17: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_18]; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_259] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24801,8 +24820,8 @@ fn aiur_fn_259( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_259] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24810,11 +24829,11 @@ fn aiur_fn_259( } }, _ => { - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_259] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24823,15 +24842,15 @@ fn aiur_fn_259( }) } -const INPUT_SIZE_260: usize = 3; -const IN_260: usize = 3; -const OUT_260: usize = 2; -fn aiur_fn_260( - inp: [G; IN_260], +const INPUT_SIZE_261: usize = 3; +const IN_261: usize = 3; +const OUT_261: usize = 2; +fn aiur_fn_261( + inp: [G; IN_261], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_260], ExecError> { +) -> Result<[G; OUT_261], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24845,8 +24864,8 @@ fn aiur_fn_260( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_260] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24856,17 +24875,17 @@ fn aiur_fn_260( let __v_7: G = G::from_u64(1); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_6]; let __cu = unconstrained; 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_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_8]; let __cu = unconstrained; 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 = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -24875,10 +24894,10 @@ fn aiur_fn_260( let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_260] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24887,8 +24906,8 @@ fn aiur_fn_260( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_260] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24899,23 +24918,23 @@ fn aiur_fn_260( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_260] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_8]; let __cu = unconstrained; 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 = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_260] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24924,8 +24943,8 @@ fn aiur_fn_260( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_260] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24936,43 +24955,43 @@ fn aiur_fn_260( }) } -const INPUT_SIZE_261: usize = 4; -const IN_261: usize = 4; -const OUT_261: usize = 2; -fn aiur_fn_261( - inp: [G; IN_261], +const INPUT_SIZE_262: usize = 4; +const IN_262: usize = 4; +const OUT_262: usize = 2; +fn aiur_fn_262( + inp: [G; IN_262], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_261], ExecError> { +) -> Result<[G; OUT_262], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; 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_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; 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 __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; 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_8: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; 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_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; 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_12: G = __r_arr[0]; let __v_13: G = (__v_11 - __v_12); let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2]; let __cu = unconstrained; 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_15: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15]; let __cu = unconstrained; 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_16: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; let __cu = unconstrained; 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_17: G = __r_arr[0]; let __v_18: G = (__v_14 - __v_17); let __v_19: G = (__v_13 * __v_18); @@ -24985,8 +25004,8 @@ fn aiur_fn_261( let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_261] = [__v_22, __v_26]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_22, __v_26]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24995,14 +25014,14 @@ fn aiur_fn_261( let __v_23: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; match __v_24.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(2); - let __ret: [G; OUT_261] = [__v_26, __v_25]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_26, __v_25]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25011,18 +25030,18 @@ fn aiur_fn_261( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_261] = [__v_26, __v_30]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_26, __v_30]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_261] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_24, __v_25]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25031,15 +25050,15 @@ fn aiur_fn_261( }) } -const INPUT_SIZE_262: usize = 4; -const IN_262: usize = 4; -const OUT_262: usize = 1; -fn aiur_fn_262( - inp: [G; IN_262], +const INPUT_SIZE_263: usize = 4; +const IN_263: usize = 4; +const OUT_263: usize = 1; +fn aiur_fn_263( + inp: [G; IN_263], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_262], ExecError> { +) -> Result<[G; OUT_263], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25055,27 +25074,27 @@ fn aiur_fn_262( let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2]; 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_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_262] = [__v_17]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_17]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_263: usize = 10; -const IN_263: usize = 10; -const OUT_263: usize = 8; -fn aiur_fn_263( - inp: [G; IN_263], +const INPUT_SIZE_264: usize = 10; +const IN_264: usize = 10; +const OUT_264: usize = 8; +fn aiur_fn_264( + inp: [G; IN_264], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_263], ExecError> { +) -> Result<[G; OUT_264], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25089,8 +25108,8 @@ fn aiur_fn_263( let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 8u64 => { - let __ret: [G; OUT_263] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25100,15 +25119,15 @@ fn aiur_fn_263( let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_263] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25117,13 +25136,13 @@ fn aiur_fn_263( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25132,13 +25151,13 @@ fn aiur_fn_263( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_13: G = G::from_u64(3); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25147,13 +25166,13 @@ fn aiur_fn_263( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_13: G = G::from_u64(4); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25162,13 +25181,13 @@ fn aiur_fn_263( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_13: G = G::from_u64(5); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25177,13 +25196,13 @@ fn aiur_fn_263( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_13: G = G::from_u64(6); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25192,13 +25211,13 @@ fn aiur_fn_263( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_13: G = G::from_u64(7); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25207,13 +25226,13 @@ fn aiur_fn_263( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(8); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -25222,8 +25241,8 @@ fn aiur_fn_263( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25237,22 +25256,22 @@ fn aiur_fn_263( }) } -const INPUT_SIZE_264: usize = 2; -const IN_264: usize = 2; -const OUT_264: usize = 1; -fn aiur_fn_264( - inp: [G; IN_264], +const INPUT_SIZE_265: usize = 2; +const IN_265: usize = 2; +const OUT_265: usize = 1; +fn aiur_fn_265( + inp: [G; IN_265], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_264], ExecError> { +) -> Result<[G; OUT_265], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_264] = [__v_0]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_0]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25265,17 +25284,17 @@ fn aiur_fn_264( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_264] = [__v_7]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_7]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_264] = [__v_7]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_7]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25287,15 +25306,15 @@ fn aiur_fn_264( }) } -const INPUT_SIZE_265: usize = 1; -const IN_265: usize = 1; -const OUT_265: usize = 1; -fn aiur_fn_265( - inp: [G; IN_265], +const INPUT_SIZE_266: usize = 1; +const IN_266: usize = 1; +const OUT_266: usize = 1; +fn aiur_fn_266( + inp: [G; IN_266], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_265], ExecError> { +) -> Result<[G; OUT_266], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -25307,7 +25326,7 @@ fn aiur_fn_265( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -25317,7 +25336,7 @@ fn aiur_fn_265( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = G::from_u64(8); - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -25331,7 +25350,7 @@ fn aiur_fn_265( break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, @@ -25351,15 +25370,15 @@ fn aiur_fn_265( let __v_33: G = __loaded[9]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; match __v_34.as_canonical_u64() { 1u64 => { let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(1); let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_265] = [__v_37]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_37]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -25368,8 +25387,8 @@ fn aiur_fn_265( let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_265] = [__v_39]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_39]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25380,23 +25399,23 @@ fn aiur_fn_265( _ => { let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_265] = [__v_35]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_35]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_266: usize = 1; -const IN_266: usize = 1; -const OUT_266: usize = 1; -fn aiur_fn_266( - inp: [G; IN_266], +const INPUT_SIZE_267: usize = 1; +const IN_267: usize = 1; +const OUT_267: usize = 1; +fn aiur_fn_267( + inp: [G; IN_267], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_266], ExecError> { +) -> Result<[G; OUT_267], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; @@ -25414,50 +25433,50 @@ fn aiur_fn_266( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_266] = [__v_12]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_12]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_266] = [__v_13]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_13]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_266] = [__v_13]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_13]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_266] = [__v_13]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_13]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(4); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_266] = [__v_13]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_13]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25467,15 +25486,15 @@ fn aiur_fn_266( }) } -const INPUT_SIZE_267: usize = 2; -const IN_267: usize = 2; -const OUT_267: usize = 1; -fn aiur_fn_267( - inp: [G; IN_267], +const INPUT_SIZE_268: usize = 2; +const IN_268: usize = 2; +const OUT_268: usize = 1; +fn aiur_fn_268( + inp: [G; IN_268], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_267], ExecError> { +) -> Result<[G; OUT_268], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25495,23 +25514,23 @@ fn aiur_fn_267( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_267] = [__v_14]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_14]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_267] = [__v_17]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_17]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25521,15 +25540,15 @@ fn aiur_fn_267( }) } -const INPUT_SIZE_268: usize = 5; -const IN_268: usize = 5; -const OUT_268: usize = 1; -fn aiur_fn_268( - inp: [G; IN_268], +const INPUT_SIZE_269: usize = 5; +const IN_269: usize = 5; +const OUT_269: usize = 1; +fn aiur_fn_269( + inp: [G; IN_269], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_268], ExecError> { +) -> Result<[G; OUT_269], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25557,156 +25576,156 @@ fn aiur_fn_268( let __v_22: G = __loaded[17]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_28]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_28]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_26]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_26]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_28]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_28]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_28]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_28]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(8); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_28]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_28]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_25]; let __cu = unconstrained; 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_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_29]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_29]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(7); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_30]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_30]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_23: G = G::from_u64(3); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_27]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_27]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_27]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_27]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { let __v_23: G = G::from_u64(5); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_27]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_27]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { let __v_23: G = G::from_u64(6); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_27]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_27]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 11u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; @@ -25716,10 +25735,10 @@ fn aiur_fn_268( let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_268] = [__v_28]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_28]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25734,15 +25753,15 @@ fn aiur_fn_268( }) } -const INPUT_SIZE_269: usize = 17; -const IN_269: usize = 17; -const OUT_269: usize = 12; -fn aiur_fn_269( - inp: [G; IN_269], +const INPUT_SIZE_270: usize = 17; +const IN_270: usize = 17; +const OUT_270: usize = 12; +fn aiur_fn_270( + inp: [G; IN_270], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_269], ExecError> { +) -> Result<[G; OUT_270], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25763,18 +25782,18 @@ fn aiur_fn_269( let __v_16: G = inp[16]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_269] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -25792,15 +25811,15 @@ fn aiur_fn_269( let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_269] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_20: G = G::from_u64(2); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_269] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25812,15 +25831,15 @@ fn aiur_fn_269( }) } -const INPUT_SIZE_270: usize = 14; -const IN_270: usize = 14; -const OUT_270: usize = 12; -fn aiur_fn_270( - inp: [G; IN_270], +const INPUT_SIZE_271: usize = 14; +const IN_271: usize = 14; +const OUT_271: usize = 12; +fn aiur_fn_271( + inp: [G; IN_271], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_270], ExecError> { +) -> Result<[G; OUT_271], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25838,29 +25857,29 @@ fn aiur_fn_270( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_270] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_271] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; + if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_271: usize = 14; -const IN_271: usize = 14; -const OUT_271: usize = 12; -fn aiur_fn_271( - inp: [G; IN_271], +const INPUT_SIZE_272: usize = 14; +const IN_272: usize = 14; +const OUT_272: usize = 12; +fn aiur_fn_272( + inp: [G; IN_272], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_271], ExecError> { +) -> Result<[G; OUT_272], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25878,29 +25897,29 @@ fn aiur_fn_271( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_271] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_272: usize = 1; -const IN_272: usize = 1; -const OUT_272: usize = 1; -fn aiur_fn_272( - inp: [G; IN_272], +const INPUT_SIZE_273: usize = 1; +const IN_273: usize = 1; +const OUT_273: usize = 1; +fn aiur_fn_273( + inp: [G; IN_273], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_272], ExecError> { +) -> Result<[G; OUT_273], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; @@ -25943,17 +25962,17 @@ fn aiur_fn_272( match __v_1.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_272] = [__v_37]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_273] = [__v_37]; + if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_37 + __v_38); - let __ret: [G; OUT_272] = [__v_39]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_273] = [__v_39]; + if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25963,15 +25982,15 @@ fn aiur_fn_272( }) } -const INPUT_SIZE_273: usize = 2; -const IN_273: usize = 2; -const OUT_273: usize = 34; -fn aiur_fn_273( - inp: [G; IN_273], +const INPUT_SIZE_274: usize = 2; +const IN_274: usize = 2; +const OUT_274: usize = 34; +fn aiur_fn_274( + inp: [G; IN_274], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_273], ExecError> { +) -> Result<[G; OUT_274], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26016,14 +26035,14 @@ fn aiur_fn_273( 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_273] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_274] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; @@ -26058,8 +26077,8 @@ fn aiur_fn_273( let __v_71: G = __r_arr[31]; let __v_72: G = __r_arr[32]; let __v_73: G = __r_arr[33]; - let __ret: [G; OUT_273] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; - if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_274] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; + if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26071,15 +26090,15 @@ fn aiur_fn_273( }) } -const INPUT_SIZE_274: usize = 33; -const IN_274: usize = 33; -const OUT_274: usize = 12; -fn aiur_fn_274( - inp: [G; IN_274], +const INPUT_SIZE_275: usize = 33; +const IN_275: usize = 33; +const OUT_275: usize = 12; +fn aiur_fn_275( + inp: [G; IN_275], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_274], ExecError> { +) -> Result<[G; OUT_275], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26116,35 +26135,35 @@ fn aiur_fn_274( let __v_32: G = inp[32]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(5); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_274] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; - if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_275] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; + if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_275: usize = 40; -const IN_275: usize = 40; -const OUT_275: usize = 12; -fn aiur_fn_275( - inp: [G; IN_275], +const INPUT_SIZE_276: usize = 40; +const IN_276: usize = 40; +const OUT_276: usize = 12; +fn aiur_fn_276( + inp: [G; IN_276], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_275], ExecError> { +) -> Result<[G; OUT_276], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26188,35 +26207,35 @@ fn aiur_fn_275( let __v_39: G = inp[39]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(6); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_275] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_276] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; + if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_276: usize = 6; -const IN_276: usize = 6; -const OUT_276: usize = 1; -fn aiur_fn_276( - inp: [G; IN_276], +const INPUT_SIZE_277: usize = 6; +const IN_277: usize = 6; +const OUT_277: usize = 1; +fn aiur_fn_277( + inp: [G; IN_277], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_276], ExecError> { +) -> Result<[G; OUT_277], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26241,25 +26260,25 @@ fn aiur_fn_276( let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_276] = [__v_19]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_277] = [__v_19]; + if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_276] = [__v_23]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_277] = [__v_23]; + if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26271,15 +26290,15 @@ fn aiur_fn_276( }) } -const INPUT_SIZE_277: usize = 50; -const IN_277: usize = 50; -const OUT_277: usize = 12; -fn aiur_fn_277( - inp: [G; IN_277], +const INPUT_SIZE_278: usize = 50; +const IN_278: usize = 50; +const OUT_278: usize = 12; +fn aiur_fn_278( + inp: [G; IN_278], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_277], ExecError> { +) -> Result<[G; OUT_278], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26333,39 +26352,39 @@ fn aiur_fn_277( let __v_49: G = inp[49]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(7); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __ret: [G; OUT_277] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_278] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; + if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_278: usize = 1; -const IN_278: usize = 1; -const OUT_278: usize = 48; -fn aiur_fn_278( - inp: [G; IN_278], +const INPUT_SIZE_279: usize = 1; +const IN_279: usize = 1; +const OUT_279: usize = 48; +fn aiur_fn_279( + inp: [G; IN_279], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_278], ExecError> { +) -> Result<[G; OUT_279], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -26406,10 +26425,10 @@ fn aiur_fn_278( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(2); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; 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 { 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_37: G = __r_arr[0]; - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_20(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -26474,21 +26493,21 @@ fn aiur_fn_278( if (__v_89 != __v_91) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) }); } - let __ret: [G; OUT_278] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; - if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_279] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; + if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_279: usize = 1; -const IN_279: usize = 1; -const OUT_279: usize = 1; -fn aiur_fn_279( - inp: [G; IN_279], +const INPUT_SIZE_280: usize = 1; +const IN_280: usize = 1; +const OUT_280: usize = 1; +fn aiur_fn_280( + inp: [G; IN_280], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_279], ExecError> { +) -> Result<[G; OUT_280], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -26529,7 +26548,7 @@ fn aiur_fn_279( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(3); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; 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 { 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_37: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_38: G = __loaded[0]; @@ -26537,8 +26556,8 @@ fn aiur_fn_279( let __v_40: G = __loaded[2]; match __v_38.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_279] = [__v_39]; - if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_280] = [__v_39]; + if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26548,15 +26567,15 @@ fn aiur_fn_279( }) } -const INPUT_SIZE_280: usize = 1; -const IN_280: usize = 1; -const OUT_280: usize = 1; -fn aiur_fn_280( - inp: [G; IN_280], +const INPUT_SIZE_281: usize = 1; +const IN_281: usize = 1; +const OUT_281: usize = 1; +fn aiur_fn_281( + inp: [G; IN_281], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_280], ExecError> { +) -> Result<[G; OUT_281], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -26597,46 +26616,46 @@ fn aiur_fn_280( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(4); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; 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 { 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_37: G = __r_arr[0]; - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_20(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_280] = [__v_37]; - if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_281] = [__v_37]; + if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_281: usize = 2; -const IN_281: usize = 2; -const OUT_281: usize = 1; -fn aiur_fn_281( - inp: [G; IN_281], +const INPUT_SIZE_282: usize = 2; +const IN_282: usize = 2; +const OUT_282: usize = 1; +fn aiur_fn_282( + inp: [G; IN_282], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_281], ExecError> { +) -> Result<[G; OUT_282], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 2u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_281] = [__v_2]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_2]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_281] = [__v_2]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_2]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_281] = [__v_2]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_2]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26645,14 +26664,14 @@ fn aiur_fn_281( match __v_1.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_281] = [__v_2]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_2]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_281] = [__v_2]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_2]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26664,15 +26683,15 @@ fn aiur_fn_281( }) } -const INPUT_SIZE_282: usize = 14; -const IN_282: usize = 14; -const OUT_282: usize = 1; -fn aiur_fn_282( - inp: [G; IN_282], +const INPUT_SIZE_283: usize = 14; +const IN_283: usize = 14; +const OUT_283: usize = 1; +fn aiur_fn_283( + inp: [G; IN_283], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_282], ExecError> { +) -> Result<[G; OUT_283], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26690,22 +26709,22 @@ fn aiur_fn_282( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_282] = [__v_17]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_17]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_282] = [__v_15]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_15]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26714,18 +26733,18 @@ fn aiur_fn_282( }) } -const INPUT_SIZE_283: usize = 1; -const IN_283: usize = 1; -const OUT_283: usize = 1; -fn aiur_fn_283( - inp: [G; IN_283], +const INPUT_SIZE_284: usize = 1; +const IN_284: usize = 1; +const OUT_284: usize = 1; +fn aiur_fn_284( + inp: [G; IN_284], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_283], ExecError> { +) -> Result<[G; OUT_284], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -26778,11 +26797,11 @@ fn aiur_fn_283( _ => { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; match __v_50.as_canonical_u64() { 0u64 => { @@ -26804,7 +26823,7 @@ fn aiur_fn_283( } }; let __v_50: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -26818,15 +26837,15 @@ fn aiur_fn_283( let __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_283] = [__v_63]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_63]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -26840,15 +26859,15 @@ fn aiur_fn_283( let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_283] = [__v_64]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_64]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -26862,17 +26881,17 @@ fn aiur_fn_283( let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_283] = [__v_64]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_64]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_283] = [__v_49]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_49]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26880,12 +26899,12 @@ fn aiur_fn_283( 6u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_283] = [__v_50]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_50]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26893,14 +26912,14 @@ fn aiur_fn_283( 4u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_283] = [__v_51]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_51]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26908,12 +26927,12 @@ fn aiur_fn_283( 5u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_283] = [__v_50]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_50]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26925,7 +26944,7 @@ fn aiur_fn_283( let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -26939,8 +26958,8 @@ fn aiur_fn_283( let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_283] = [__v_67]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_67]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26952,15 +26971,15 @@ fn aiur_fn_283( }) } -const INPUT_SIZE_284: usize = 10; -const IN_284: usize = 10; -const OUT_284: usize = 1; -fn aiur_fn_284( - inp: [G; IN_284], +const INPUT_SIZE_285: usize = 10; +const IN_285: usize = 10; +const OUT_285: usize = 1; +fn aiur_fn_285( + inp: [G; IN_285], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_284], ExecError> { +) -> Result<[G; OUT_285], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26972,7 +26991,7 @@ fn aiur_fn_284( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -27073,11 +27092,11 @@ fn aiur_fn_284( let __v_102: G = __r_arr[44]; match __v_58.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; @@ -27091,8 +27110,8 @@ fn aiur_fn_284( let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_284] = [__v_117]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_117]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27109,19 +27128,19 @@ fn aiur_fn_284( }) } -const INPUT_SIZE_285: usize = 2; -const IN_285: usize = 2; -const OUT_285: usize = 1; -fn aiur_fn_285( - inp: [G; IN_285], +const INPUT_SIZE_286: usize = 2; +const IN_286: usize = 2; +const OUT_286: usize = 1; +fn aiur_fn_286( + inp: [G; IN_286], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_285], ExecError> { +) -> Result<[G; OUT_286], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -27174,7 +27193,7 @@ fn aiur_fn_285( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -27222,9 +27241,9 @@ fn aiur_fn_285( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27238,8 +27257,8 @@ fn aiur_fn_285( let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_285] = [__v_108]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_286] = [__v_108]; + if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27256,20 +27275,20 @@ fn aiur_fn_285( }) } -const INPUT_SIZE_286: usize = 3; -const IN_286: usize = 3; -const OUT_286: usize = 1; -fn aiur_fn_286( - inp: [G; IN_286], +const INPUT_SIZE_287: usize = 3; +const IN_287: usize = 3; +const OUT_287: usize = 1; +fn aiur_fn_287( + inp: [G; IN_287], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_286], ExecError> { +) -> Result<[G; OUT_287], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -27322,7 +27341,7 @@ fn aiur_fn_286( _ => { match __v_3.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -27372,7 +27391,7 @@ fn aiur_fn_286( 1u64 => { match __v_52.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27407,9 +27426,9 @@ fn aiur_fn_286( let __v_127: G = __r_arr[31]; let __v_128: G = __r_arr[32]; let __v_129: G = __r_arr[33]; - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_130: G = __r_arr[0]; - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = __r_arr[1]; let __v_133: G = __r_arr[2]; @@ -27423,8 +27442,8 @@ fn aiur_fn_286( let __v_141: G = __r_arr[10]; let __v_142: G = __r_arr[11]; let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_286] = [__v_143]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_143]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27443,19 +27462,19 @@ fn aiur_fn_286( }) } -const INPUT_SIZE_287: usize = 2; -const IN_287: usize = 2; -const OUT_287: usize = 1; -fn aiur_fn_287( - inp: [G; IN_287], +const INPUT_SIZE_288: usize = 2; +const IN_288: usize = 2; +const OUT_288: usize = 1; +fn aiur_fn_288( + inp: [G; IN_288], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_287], ExecError> { +) -> Result<[G; OUT_288], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -27508,7 +27527,7 @@ fn aiur_fn_287( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -27556,9 +27575,9 @@ fn aiur_fn_287( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27572,8 +27591,8 @@ fn aiur_fn_287( let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_108]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_288] = [__v_108]; + if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27590,15 +27609,15 @@ fn aiur_fn_287( }) } -const INPUT_SIZE_288: usize = 2; -const IN_288: usize = 2; -const OUT_288: usize = 45; -fn aiur_fn_288( - inp: [G; IN_288], +const INPUT_SIZE_289: usize = 2; +const IN_289: usize = 2; +const OUT_289: usize = 45; +fn aiur_fn_289( + inp: [G; IN_289], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_288], ExecError> { +) -> Result<[G; OUT_289], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27654,14 +27673,14 @@ fn aiur_fn_288( 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_288] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_289] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; + if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 - __v_49); - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -27707,8 +27726,8 @@ fn aiur_fn_288( let __v_93: G = __r_arr[42]; let __v_94: G = __r_arr[43]; let __v_95: G = __r_arr[44]; - let __ret: [G; OUT_288] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_289] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; + if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27720,15 +27739,15 @@ fn aiur_fn_288( }) } -const INPUT_SIZE_289: usize = 1; -const IN_289: usize = 1; -const OUT_289: usize = 8; -fn aiur_fn_289( - inp: [G; IN_289], +const INPUT_SIZE_290: usize = 1; +const IN_290: usize = 1; +const OUT_290: usize = 8; +fn aiur_fn_290( + inp: [G; IN_290], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_289], ExecError> { +) -> Result<[G; OUT_290], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); @@ -27744,31 +27763,31 @@ fn aiur_fn_289( if !unconstrained { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; if !unconstrained { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; if !unconstrained { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; if (__v_9 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection index bytes do not recompose to the index".to_string()) }); } - let __ret: [G; OUT_289] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_290] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_290: usize = 3; -const IN_290: usize = 3; -const OUT_290: usize = 1; -fn aiur_fn_290( - inp: [G; IN_290], +const INPUT_SIZE_291: usize = 3; +const IN_291: usize = 3; +const OUT_291: usize = 1; +fn aiur_fn_291( + inp: [G; IN_291], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_290], ExecError> { +) -> Result<[G; OUT_291], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -27814,7 +27833,7 @@ fn aiur_fn_290( let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -27901,46 +27920,46 @@ fn aiur_fn_290( let __v_110: G = G::from_u64(1); let __v_111: G = G::from_u64(1); let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; 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_113: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_113]; let __cu = unconstrained; 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 __v_114: G = __r_arr[0]; - let __ret: [G; OUT_290] = [__v_114]; - if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_291] = [__v_114]; + if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_291: usize = 2; -const IN_291: usize = 2; -const OUT_291: usize = 1; -fn aiur_fn_291( - inp: [G; IN_291], +const INPUT_SIZE_292: usize = 2; +const IN_292: usize = 2; +const OUT_292: usize = 1; +fn aiur_fn_292( + inp: [G; IN_292], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_291], ExecError> { +) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_291] = [__v_3]; - if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_292] = [__v_3]; + if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_292: usize = 4; -const IN_292: usize = 4; -const OUT_292: usize = 1; -fn aiur_fn_292( - inp: [G; IN_292], +const INPUT_SIZE_293: usize = 4; +const IN_293: usize = 4; +const OUT_293: usize = 1; +fn aiur_fn_293( + inp: [G; IN_293], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_292], ExecError> { +) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27999,21 +28018,21 @@ fn aiur_fn_292( let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_292] = [__v_53]; - if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_53]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_3 + __v_53); - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_292] = [__v_56]; - if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_56]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28023,15 +28042,15 @@ fn aiur_fn_292( }) } -const INPUT_SIZE_293: usize = 1; -const IN_293: usize = 1; -const OUT_293: usize = 1; -fn aiur_fn_293( - inp: [G; IN_293], +const INPUT_SIZE_294: usize = 1; +const IN_294: usize = 1; +const OUT_294: usize = 1; +fn aiur_fn_294( + inp: [G; IN_294], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_293], ExecError> { +) -> Result<[G; OUT_294], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -28041,57 +28060,57 @@ fn aiur_fn_293( match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_293] = [__v_4]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_4]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_293] = [__v_4]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_4]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_293] = [__v_4]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_4]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_293] = [__v_6]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_6]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_293] = [__v_6]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_6]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_293] = [__v_6]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_6]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_293] = [__v_4]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_4]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28101,15 +28120,15 @@ fn aiur_fn_293( }) } -const INPUT_SIZE_294: usize = 2; -const IN_294: usize = 2; -const OUT_294: usize = 1; -fn aiur_fn_294( - inp: [G; IN_294], +const INPUT_SIZE_295: usize = 2; +const IN_295: usize = 2; +const OUT_295: usize = 1; +fn aiur_fn_295( + inp: [G; IN_295], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_294], ExecError> { +) -> Result<[G; OUT_295], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28126,14 +28145,14 @@ fn aiur_fn_294( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28145,16 +28164,16 @@ fn aiur_fn_294( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28166,19 +28185,19 @@ fn aiur_fn_294( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); - let __ret: [G; OUT_294] = [__v_10]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_10]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28190,19 +28209,19 @@ fn aiur_fn_294( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); - let __ret: [G; OUT_294] = [__v_10]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_10]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28216,14 +28235,14 @@ fn aiur_fn_294( 4u64 => { let __v_8: G = (__v_3 - __v_6); let __v_9: G = G::from_bool((__v_8 == G::ZERO)); - let __ret: [G; OUT_294] = [__v_9]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_9]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_294] = [__v_8]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_8]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28235,15 +28254,15 @@ fn aiur_fn_294( }) } -const INPUT_SIZE_295: usize = 2; -const IN_295: usize = 2; -const OUT_295: usize = 1; -fn aiur_fn_295( - inp: [G; IN_295], +const INPUT_SIZE_296: usize = 2; +const IN_296: usize = 2; +const OUT_296: usize = 1; +fn aiur_fn_296( + inp: [G; IN_296], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_295], ExecError> { +) -> Result<[G; OUT_296], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28260,14 +28279,14 @@ fn aiur_fn_295( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_8]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_8]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28283,8 +28302,8 @@ fn aiur_fn_295( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_295] = [__v_8]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_8]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28292,8 +28311,8 @@ fn aiur_fn_295( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_295] = [__v_9]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_9]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28301,15 +28320,15 @@ fn aiur_fn_295( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(2); - let __ret: [G; OUT_295] = [__v_10]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_10]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_295] = [__v_10]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_10]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28334,15 +28353,15 @@ fn aiur_fn_295( }) } -const INPUT_SIZE_296: usize = 2; -const IN_296: usize = 2; -const OUT_296: usize = 1; -fn aiur_fn_296( - inp: [G; IN_296], +const INPUT_SIZE_297: usize = 2; +const IN_297: usize = 2; +const OUT_297: usize = 1; +fn aiur_fn_297( + inp: [G; IN_297], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_296], ExecError> { +) -> Result<[G; OUT_297], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28353,8 +28372,8 @@ fn aiur_fn_296( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_296] = [__v_5]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_5]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28365,8 +28384,8 @@ fn aiur_fn_296( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_296] = [__v_8]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_8]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28374,25 +28393,25 @@ fn aiur_fn_296( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_296] = [__v_9]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_9]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_296] = [__v_10]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_10]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_296] = [__v_10]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_10]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28417,15 +28436,15 @@ fn aiur_fn_296( }) } -const INPUT_SIZE_297: usize = 2; -const IN_297: usize = 2; -const OUT_297: usize = 1; -fn aiur_fn_297( - inp: [G; IN_297], +const INPUT_SIZE_298: usize = 2; +const IN_298: usize = 2; +const OUT_298: usize = 1; +fn aiur_fn_298( + inp: [G; IN_298], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_297], ExecError> { +) -> Result<[G; OUT_298], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28442,14 +28461,14 @@ fn aiur_fn_297( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28465,15 +28484,15 @@ fn aiur_fn_297( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_297] = [__v_8]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28488,15 +28507,15 @@ fn aiur_fn_297( }) } -const INPUT_SIZE_298: usize = 2; -const IN_298: usize = 2; -const OUT_298: usize = 2; -fn aiur_fn_298( - inp: [G; IN_298], +const INPUT_SIZE_299: usize = 2; +const IN_299: usize = 2; +const OUT_299: usize = 2; +fn aiur_fn_299( + inp: [G; IN_299], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_298], ExecError> { +) -> Result<[G; OUT_299], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28512,8 +28531,8 @@ fn aiur_fn_298( let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_298] = [__v_5, __v_10]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_5, __v_10]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28523,8 +28542,8 @@ fn aiur_fn_298( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_298] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_6, __v_8]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28532,18 +28551,18 @@ fn aiur_fn_298( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_7, __v_1]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_7, __v_1]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_298] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28563,15 +28582,15 @@ fn aiur_fn_298( }) } -const INPUT_SIZE_299: usize = 3; -const IN_299: usize = 3; -const OUT_299: usize = 1; -fn aiur_fn_299( - inp: [G; IN_299], +const INPUT_SIZE_300: usize = 3; +const IN_300: usize = 3; +const OUT_300: usize = 1; +fn aiur_fn_300( + inp: [G; IN_300], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_299], ExecError> { +) -> Result<[G; OUT_300], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28588,8 +28607,8 @@ fn aiur_fn_299( let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_299] = [__v_11]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_11]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28604,8 +28623,8 @@ fn aiur_fn_299( let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_299] = [__v_11]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_11]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28613,11 +28632,11 @@ fn aiur_fn_299( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_299] = [__v_12]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_12]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28627,13 +28646,13 @@ fn aiur_fn_299( let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_299] = [__v_13]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_13]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_299] = [__v_0]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_0]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28660,15 +28679,15 @@ fn aiur_fn_299( }) } -const INPUT_SIZE_300: usize = 2; -const IN_300: usize = 2; -const OUT_300: usize = 1; -fn aiur_fn_300( - inp: [G; IN_300], +const INPUT_SIZE_301: usize = 2; +const IN_301: usize = 2; +const OUT_301: usize = 1; +fn aiur_fn_301( + inp: [G; IN_301], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_300], ExecError> { +) -> Result<[G; OUT_301], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28685,14 +28704,14 @@ fn aiur_fn_300( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_300] = [__v_8]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_8]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28708,8 +28727,8 @@ fn aiur_fn_300( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_8]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28729,24 +28748,24 @@ fn aiur_fn_300( let __v_13: G = (__v_9 - __v_11); match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_300] = [__v_14]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_14]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_14]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_14]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_13]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_13]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28767,15 +28786,15 @@ fn aiur_fn_300( }) } -const INPUT_SIZE_301: usize = 1; -const IN_301: usize = 1; -const OUT_301: usize = 1; -fn aiur_fn_301( - inp: [G; IN_301], +const INPUT_SIZE_302: usize = 1; +const IN_302: usize = 1; +const OUT_302: usize = 1; +fn aiur_fn_302( + inp: [G; IN_302], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_301], ExecError> { +) -> Result<[G; OUT_302], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -28785,8 +28804,8 @@ fn aiur_fn_301( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_4]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_4]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28795,18 +28814,18 @@ fn aiur_fn_301( let __v_5: G = __loaded[1]; match __v_4.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_301] = [__v_5]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_5]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_301] = [__v_6]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_6]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28823,15 +28842,15 @@ fn aiur_fn_301( }) } -const INPUT_SIZE_302: usize = 2; -const IN_302: usize = 2; -const OUT_302: usize = 1; -fn aiur_fn_302( - inp: [G; IN_302], +const INPUT_SIZE_303: usize = 2; +const IN_303: usize = 2; +const OUT_303: usize = 1; +fn aiur_fn_303( + inp: [G; IN_303], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_302], ExecError> { +) -> Result<[G; OUT_303], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28841,8 +28860,8 @@ fn aiur_fn_302( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_302] = [__v_0]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_0]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28852,8 +28871,8 @@ fn aiur_fn_302( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_302] = [__v_0]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_0]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28871,21 +28890,21 @@ fn aiur_fn_302( match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_15]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_15]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_302] = [__v_14]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_14]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28893,18 +28912,18 @@ fn aiur_fn_302( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_17]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_17]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_302] = [__v_15]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_15]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28938,23 +28957,23 @@ fn aiur_fn_302( }) } -const INPUT_SIZE_303: usize = 3; -const IN_303: usize = 3; -const OUT_303: usize = 1; -fn aiur_fn_303( - inp: [G; IN_303], +const INPUT_SIZE_304: usize = 3; +const IN_304: usize = 3; +const OUT_304: usize = 1; +fn aiur_fn_304( + inp: [G; IN_304], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_303], ExecError> { +) -> Result<[G; OUT_304], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_303] = [__v_0]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_0]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -28964,15 +28983,15 @@ fn aiur_fn_303( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_303] = [__v_6]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_6]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_303] = [__v_0]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_0]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28981,25 +29000,25 @@ fn aiur_fn_303( } }, _ => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_303] = [__v_3]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_3]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_304: usize = 3; -const IN_304: usize = 3; -const OUT_304: usize = 1; -fn aiur_fn_304( - inp: [G; IN_304], +const INPUT_SIZE_305: usize = 3; +const IN_305: usize = 3; +const OUT_305: usize = 1; +fn aiur_fn_305( + inp: [G; IN_305], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_304], ExecError> { +) -> Result<[G; OUT_305], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29019,8 +29038,8 @@ fn aiur_fn_304( let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_304] = [__v_14]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_14]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29030,7 +29049,7 @@ fn aiur_fn_304( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { @@ -29040,13 +29059,13 @@ fn aiur_fn_304( let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_304] = [__v_13]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_13]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_304] = [__v_0]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_0]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29061,17 +29080,17 @@ fn aiur_fn_304( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_304] = [__v_15]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_15]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_304] = [__v_12]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_12]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29085,15 +29104,15 @@ fn aiur_fn_304( }) } -const INPUT_SIZE_305: usize = 4; -const IN_305: usize = 4; -const OUT_305: usize = 1; -fn aiur_fn_305( - inp: [G; IN_305], +const INPUT_SIZE_306: usize = 4; +const IN_306: usize = 4; +const OUT_306: usize = 1; +fn aiur_fn_306( + inp: [G; IN_306], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_305], ExecError> { +) -> Result<[G; OUT_306], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29118,8 +29137,8 @@ fn aiur_fn_305( let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_305] = [__v_19]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_19]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29129,17 +29148,17 @@ fn aiur_fn_305( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_305] = [__v_14]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_14]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -29153,17 +29172,17 @@ fn aiur_fn_305( let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_305] = [__v_20]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_20]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_305] = [__v_13]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_13]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29177,15 +29196,15 @@ fn aiur_fn_305( }) } -const INPUT_SIZE_306: usize = 4; -const IN_306: usize = 4; -const OUT_306: usize = 1; -fn aiur_fn_306( - inp: [G; IN_306], +const INPUT_SIZE_307: usize = 4; +const IN_307: usize = 4; +const OUT_307: usize = 1; +fn aiur_fn_307( + inp: [G; IN_307], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_306], ExecError> { +) -> Result<[G; OUT_307], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29197,63 +29216,63 @@ fn aiur_fn_306( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_7]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_7]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_9]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_9]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_8]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_8]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_7]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_7]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_10]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_10]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_306] = [__v_3]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_3]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_9]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_9]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29270,15 +29289,15 @@ fn aiur_fn_306( }) } -const INPUT_SIZE_307: usize = 5; -const IN_307: usize = 5; -const OUT_307: usize = 1; -fn aiur_fn_307( - inp: [G; IN_307], +const INPUT_SIZE_308: usize = 5; +const IN_308: usize = 5; +const OUT_308: usize = 1; +fn aiur_fn_308( + inp: [G; IN_308], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_307], ExecError> { +) -> Result<[G; OUT_308], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29291,55 +29310,55 @@ fn aiur_fn_307( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_8]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_8]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_3 + __v_8); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_11]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_11]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_9]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_9]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_9]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_9]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_12]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_12]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29348,17 +29367,17 @@ fn aiur_fn_307( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_11]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_11]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29373,15 +29392,15 @@ fn aiur_fn_307( }) } -const INPUT_SIZE_308: usize = 2; -const IN_308: usize = 2; -const OUT_308: usize = 1; -fn aiur_fn_308( - inp: [G; IN_308], +const INPUT_SIZE_309: usize = 2; +const IN_309: usize = 2; +const OUT_309: usize = 1; +fn aiur_fn_309( + inp: [G; IN_309], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_308], ExecError> { +) -> Result<[G; OUT_309], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29391,19 +29410,19 @@ fn aiur_fn_308( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_308] = [__v_0]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_0]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_8]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_8]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29413,15 +29432,15 @@ fn aiur_fn_308( }) } -const INPUT_SIZE_309: usize = 2; -const IN_309: usize = 2; -const OUT_309: usize = 1; -fn aiur_fn_309( - inp: [G; IN_309], +const INPUT_SIZE_310: usize = 2; +const IN_310: usize = 2; +const OUT_310: usize = 1; +fn aiur_fn_310( + inp: [G; IN_310], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_309], ExecError> { +) -> Result<[G; OUT_310], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29431,8 +29450,8 @@ fn aiur_fn_309( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_309] = [__v_0]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_0]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29448,18 +29467,18 @@ fn aiur_fn_309( let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_309] = [__v_12]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_12]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { @@ -29492,7 +29511,7 @@ fn aiur_fn_309( break '__mc_2 [__v_17]; }, 0u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 + __v_18); @@ -29533,7 +29552,7 @@ fn aiur_fn_309( break '__mc_3 [__v_7]; }, 0u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_3 [__v_17]; }, @@ -29549,10 +29568,10 @@ fn aiur_fn_309( }; let __v_14: G = __mc_out___mc_3[0]; let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_309] = [__v_16]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_16]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29568,15 +29587,15 @@ fn aiur_fn_309( }) } -const INPUT_SIZE_310: usize = 1; -const IN_310: usize = 1; -const OUT_310: usize = 1; -fn aiur_fn_310( - inp: [G; IN_310], +const INPUT_SIZE_311: usize = 1; +const IN_311: usize = 1; +const OUT_311: usize = 1; +fn aiur_fn_311( + inp: [G; IN_311], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_310], ExecError> { +) -> Result<[G; OUT_311], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -29585,8 +29604,8 @@ fn aiur_fn_310( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_310] = [__v_0]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_0]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29604,15 +29623,15 @@ fn aiur_fn_310( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_10]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_10]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_310] = [__v_0]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_0]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29621,8 +29640,8 @@ fn aiur_fn_310( } }, _ => { - let __ret: [G; OUT_310] = [__v_0]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_0]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29636,21 +29655,21 @@ fn aiur_fn_310( }) } -const INPUT_SIZE_311: usize = 2; -const IN_311: usize = 2; -const OUT_311: usize = 1; -fn aiur_fn_311( - inp: [G; IN_311], +const INPUT_SIZE_312: usize = 2; +const IN_312: usize = 2; +const OUT_312: usize = 1; +fn aiur_fn_312( + inp: [G; IN_312], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_311], ExecError> { +) -> Result<[G; OUT_312], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -29665,14 +29684,14 @@ fn aiur_fn_311( match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_311] = [__v_10]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_10]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_311] = [__v_10]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_10]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29688,8 +29707,8 @@ fn aiur_fn_311( match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_311] = [__v_10]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_10]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29705,27 +29724,27 @@ fn aiur_fn_311( let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = (__v_11 - __v_14); match __v_17.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_19]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_19]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_311] = [__v_19]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_19]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29735,16 +29754,16 @@ fn aiur_fn_311( }, _ => { let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_311] = [__v_18]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_18]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_311] = [__v_17]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_17]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29765,15 +29784,15 @@ fn aiur_fn_311( }) } -const INPUT_SIZE_312: usize = 3; -const IN_312: usize = 3; -const OUT_312: usize = 1; -fn aiur_fn_312( - inp: [G; IN_312], +const INPUT_SIZE_313: usize = 3; +const IN_313: usize = 3; +const OUT_313: usize = 1; +fn aiur_fn_313( + inp: [G; IN_313], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_312], ExecError> { +) -> Result<[G; OUT_313], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29785,8 +29804,8 @@ fn aiur_fn_312( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_312] = [__v_6]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_6]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29796,14 +29815,14 @@ fn aiur_fn_312( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_312] = [__v_10]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_10]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29814,7 +29833,7 @@ fn aiur_fn_312( break '__mc_0 [__v_11]; }, 1u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -29827,15 +29846,15 @@ fn aiur_fn_312( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_312] = [__v_12]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_12]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_312] = [__v_12]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_12]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29854,15 +29873,15 @@ fn aiur_fn_312( }) } -const INPUT_SIZE_313: usize = 2; -const IN_313: usize = 2; -const OUT_313: usize = 1; -fn aiur_fn_313( - inp: [G; IN_313], +const INPUT_SIZE_314: usize = 2; +const IN_314: usize = 2; +const OUT_314: usize = 1; +fn aiur_fn_314( + inp: [G; IN_314], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_313], ExecError> { +) -> Result<[G; OUT_314], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29873,8 +29892,8 @@ fn aiur_fn_313( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_313] = [__v_5]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_5]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29889,15 +29908,15 @@ fn aiur_fn_313( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_313] = [__v_10]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_10]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_313] = [__v_10]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_10]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29914,15 +29933,15 @@ fn aiur_fn_313( }) } -const INPUT_SIZE_314: usize = 4; -const IN_314: usize = 4; -const OUT_314: usize = 1; -fn aiur_fn_314( - inp: [G; IN_314], +const INPUT_SIZE_315: usize = 4; +const IN_315: usize = 4; +const OUT_315: usize = 1; +fn aiur_fn_315( + inp: [G; IN_315], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_314], ExecError> { +) -> Result<[G; OUT_315], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29935,8 +29954,8 @@ fn aiur_fn_314( match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_314] = [__v_7]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_7]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29946,31 +29965,31 @@ fn aiur_fn_314( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_11]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_11]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_314] = [__v_12]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_12]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_12]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_12]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29989,15 +30008,15 @@ fn aiur_fn_314( }) } -const INPUT_SIZE_315: usize = 3; -const IN_315: usize = 3; -const OUT_315: usize = 1; -fn aiur_fn_315( - inp: [G; IN_315], +const INPUT_SIZE_316: usize = 3; +const IN_316: usize = 3; +const OUT_316: usize = 1; +fn aiur_fn_316( + inp: [G; IN_316], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_315], ExecError> { +) -> Result<[G; OUT_316], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30009,8 +30028,8 @@ fn aiur_fn_315( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_6]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_6]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30026,15 +30045,15 @@ fn aiur_fn_315( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_315] = [__v_10]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_10]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_10]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_10]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30043,10 +30062,10 @@ fn aiur_fn_315( } }, _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_9]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_9]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30060,15 +30079,15 @@ fn aiur_fn_315( }) } -const INPUT_SIZE_316: usize = 2; -const IN_316: usize = 2; -const OUT_316: usize = 1; -fn aiur_fn_316( - inp: [G; IN_316], +const INPUT_SIZE_317: usize = 2; +const IN_317: usize = 2; +const OUT_317: usize = 1; +fn aiur_fn_317( + inp: [G; IN_317], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_316], ExecError> { +) -> Result<[G; OUT_317], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30079,8 +30098,8 @@ fn aiur_fn_316( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_316] = [__v_5]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_5]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30096,7 +30115,7 @@ fn aiur_fn_316( break '__mc_0 [__v_8]; }, _ => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, @@ -30106,25 +30125,25 @@ fn aiur_fn_316( match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_316] = [__v_9]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_9]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_316] = [__v_10]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_10]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_316] = [__v_10]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_10]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30146,15 +30165,15 @@ fn aiur_fn_316( }) } -const INPUT_SIZE_317: usize = 3; -const IN_317: usize = 3; -const OUT_317: usize = 1; -fn aiur_fn_317( - inp: [G; IN_317], +const INPUT_SIZE_318: usize = 3; +const IN_318: usize = 3; +const OUT_318: usize = 1; +fn aiur_fn_318( + inp: [G; IN_318], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_317], ExecError> { +) -> Result<[G; OUT_318], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30166,8 +30185,8 @@ fn aiur_fn_317( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_317] = [__v_6]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_6]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30176,20 +30195,20 @@ fn aiur_fn_317( let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_317] = [__v_9]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_9]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_317] = [__v_9]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_9]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30206,15 +30225,15 @@ fn aiur_fn_317( }) } -const INPUT_SIZE_318: usize = 1; -const IN_318: usize = 1; -const OUT_318: usize = 1; -fn aiur_fn_318( - inp: [G; IN_318], +const INPUT_SIZE_319: usize = 1; +const IN_319: usize = 1; +const OUT_319: usize = 1; +fn aiur_fn_319( + inp: [G; IN_319], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_318], ExecError> { +) -> Result<[G; OUT_319], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -30234,69 +30253,16 @@ fn aiur_fn_318( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_318] = [__v_19]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_19]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_319: usize = 2; -const IN_319: usize = 2; -const OUT_319: usize = 1; -fn aiur_fn_319( - inp: [G; IN_319], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_319], 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_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; - let __v_2: G = __r_arr[0]; - match __v_2.as_canonical_u64() { - 1u64 => { - let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_319] = [__v_3]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_3: G = __loaded[0]; - let __v_4: G = __loaded[1]; - let __v_5: G = __loaded[2]; - match __v_3.as_canonical_u64() { - 0u64 => { - let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_319] = [__v_6]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_319] = [__v_8]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - } - }, - _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); - }, - } - }) -} - const INPUT_SIZE_320: usize = 2; const IN_320: usize = 2; const OUT_320: usize = 1; @@ -30309,7 +30275,7 @@ fn aiur_fn_320( 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_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { @@ -30319,15 +30285,29 @@ fn aiur_fn_320( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; - let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_320] = [__v_5]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_320] = [__v_6]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_320] = [__v_8]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); @@ -30348,12 +30328,51 @@ fn aiur_fn_321( 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_326] = { let __args: [G; IN_326] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_321] = [__v_3]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_321] = [__v_5]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_322: usize = 2; +const IN_322: usize = 2; +const OUT_322: usize = 1; +fn aiur_fn_322( + inp: [G; IN_322], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_322], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -30361,13 +30380,13 @@ fn aiur_fn_321( let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_321] = [__v_1]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_1]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_321] = [__v_0]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_0]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30376,43 +30395,43 @@ fn aiur_fn_321( } }, _ => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_321] = [__v_6]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_6]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_321] = [__v_4]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_4]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_322: usize = 2; -const IN_322: usize = 2; -const OUT_322: usize = 1; -fn aiur_fn_322( - inp: [G; IN_322], +const INPUT_SIZE_323: usize = 2; +const IN_323: usize = 2; +const OUT_323: usize = 1; +fn aiur_fn_323( + inp: [G; IN_323], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_322], ExecError> { +) -> Result<[G; OUT_323], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_322] = [__v_0]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_0]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30422,8 +30441,8 @@ fn aiur_fn_322( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_322] = [__v_1]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_1]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30433,33 +30452,33 @@ fn aiur_fn_322( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_322] = [__v_0]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_0]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_322] = [__v_1]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_1]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_322] = [__v_0]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_0]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_322] = [__v_11]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_11]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30483,15 +30502,15 @@ fn aiur_fn_322( }) } -const INPUT_SIZE_323: usize = 2; -const IN_323: usize = 2; -const OUT_323: usize = 1; -fn aiur_fn_323( - inp: [G; IN_323], +const INPUT_SIZE_324: usize = 2; +const IN_324: usize = 2; +const OUT_324: usize = 1; +fn aiur_fn_324( + inp: [G; IN_324], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_323], ExecError> { +) -> Result<[G; OUT_324], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30499,8 +30518,8 @@ fn aiur_fn_323( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_323] = [__v_3]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_3]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30517,14 +30536,14 @@ fn aiur_fn_323( match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30536,16 +30555,16 @@ fn aiur_fn_323( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30557,19 +30576,19 @@ fn aiur_fn_323( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_323] = [__v_11]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_11]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30581,19 +30600,19 @@ fn aiur_fn_323( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_323] = [__v_11]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_11]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30609,22 +30628,22 @@ fn aiur_fn_323( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_323] = [__v_10]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_10]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_323] = [__v_10]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_10]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_323] = [__v_9]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_9]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30638,15 +30657,15 @@ fn aiur_fn_323( }) } -const INPUT_SIZE_324: usize = 2; -const IN_324: usize = 2; -const OUT_324: usize = 1; -fn aiur_fn_324( - inp: [G; IN_324], +const INPUT_SIZE_325: usize = 2; +const IN_325: usize = 2; +const OUT_325: usize = 1; +fn aiur_fn_325( + inp: [G; IN_325], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_324], ExecError> { +) -> Result<[G; OUT_325], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30656,20 +30675,20 @@ fn aiur_fn_324( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_324] = [__v_6]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_6]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_324] = [__v_6]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_6]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30679,48 +30698,48 @@ fn aiur_fn_324( }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_324] = [__v_5]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_5]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_325: usize = 2; -const IN_325: usize = 2; -const OUT_325: usize = 1; -fn aiur_fn_325( - inp: [G; IN_325], +const INPUT_SIZE_326: usize = 2; +const IN_326: usize = 2; +const OUT_326: usize = 1; +fn aiur_fn_326( + inp: [G; IN_326], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_325], ExecError> { +) -> Result<[G; OUT_326], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_325] = [__v_1]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_1]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_325] = [__v_0]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_0]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30731,8 +30750,8 @@ fn aiur_fn_325( 0u64 => { let __v_9: G = G::from_u64(2); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_325] = [__v_10]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_10]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30742,15 +30761,15 @@ fn aiur_fn_325( }) } -const INPUT_SIZE_326: usize = 1; -const IN_326: usize = 1; -const OUT_326: usize = 2; -fn aiur_fn_326( - inp: [G; IN_326], +const INPUT_SIZE_327: usize = 1; +const IN_327: usize = 1; +const OUT_327: usize = 2; +fn aiur_fn_327( + inp: [G; IN_327], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_326], ExecError> { +) -> Result<[G; OUT_327], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -30761,12 +30780,12 @@ fn aiur_fn_326( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_326] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -30774,15 +30793,15 @@ fn aiur_fn_326( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_5 + __v_7); - let __ret: [G; OUT_326] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_6, __v_8]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_326] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30790,23 +30809,23 @@ fn aiur_fn_326( _ => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_326] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_327: usize = 2; -const IN_327: usize = 2; -const OUT_327: usize = 2; -fn aiur_fn_327( - inp: [G; IN_327], +const INPUT_SIZE_328: usize = 2; +const IN_328: usize = 2; +const OUT_328: usize = 2; +fn aiur_fn_328( + inp: [G; IN_328], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_327], ExecError> { +) -> Result<[G; OUT_328], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30818,31 +30837,31 @@ fn aiur_fn_327( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_327] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_327] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_328: usize = 2; -const IN_328: usize = 2; -const OUT_328: usize = 1; -fn aiur_fn_328( - inp: [G; IN_328], +const INPUT_SIZE_329: usize = 2; +const IN_329: usize = 2; +const OUT_329: usize = 1; +fn aiur_fn_329( + inp: [G; IN_329], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_328], ExecError> { +) -> Result<[G; OUT_329], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30855,26 +30874,26 @@ fn aiur_fn_328( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_328] = [__v_7]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_7]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_328] = [__v_5]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_5]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_328] = [__v_6]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_6]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30884,24 +30903,24 @@ fn aiur_fn_328( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_328] = [__v_1]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_1]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_328] = [__v_0]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_0]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(3); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_328] = [__v_11]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_11]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30920,15 +30939,15 @@ fn aiur_fn_328( }) } -const INPUT_SIZE_329: usize = 1; -const IN_329: usize = 1; -const OUT_329: usize = 1; -fn aiur_fn_329( - inp: [G; IN_329], +const INPUT_SIZE_330: usize = 1; +const IN_330: usize = 1; +const OUT_330: usize = 1; +fn aiur_fn_330( + inp: [G; IN_330], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_329], ExecError> { +) -> Result<[G; OUT_330], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -30940,123 +30959,52 @@ fn aiur_fn_329( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_6]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_6]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_6]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_6]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_7]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 2u64 => { - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_329] = [__v_6]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 3u64 => { - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_329] = [__v_6]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_330: usize = 2; -const IN_330: usize = 2; -const OUT_330: usize = 1; -fn aiur_fn_330( - inp: [G; IN_330], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_330], 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() { - 0u64 => { - let __v_5: G = G::from_u64(0); - let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_330] = [__v_7]; if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, - 1u64 => { - let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_330] = [__v_8]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, 2u64 => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_330] = [__v_7]; + let __ret: [G; OUT_330] = [__v_6]; if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_330] = [__v_7]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 4u64 => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_330] = [__v_5]; + let __ret: [G; OUT_330] = [__v_6]; if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) @@ -31079,25 +31027,53 @@ fn aiur_fn_331( let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { - 1u64 => { - let __v_5: G = G::from_u64(1); - let __v_6: G = G::from_u64(1); + 0u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_331] = [__v_7]; if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, - 0u64 => { - let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + 1u64 => { + let __v_5: G = G::from_u64(1); + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __ret: [G; OUT_331] = [__v_8]; if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, + 2u64 => { + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_331] = [__v_7]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_331] = [__v_7]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_331] = [__v_5]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, _ => { return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, @@ -31117,23 +31093,33 @@ fn aiur_fn_332( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_332] = [__v_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_332] = [__v_7]; if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, - _ => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_332] = [__v_5]; + 0u64 => { + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_332] = [__v_8]; if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, } }) } @@ -31147,6 +31133,39 @@ fn aiur_fn_333( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_333], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_333] = [__v_0]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_333] = [__v_5]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_334: usize = 2; +const IN_334: usize = 2; +const OUT_334: usize = 1; +fn aiur_fn_334( + inp: [G; IN_334], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_334], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31160,94 +31179,94 @@ fn aiur_fn_333( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_8]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_8]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_9]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_9]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_9]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_9]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_6: G = G::from_u64(3); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_10]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_10]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_6: G = G::from_u64(4); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_10]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_10]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_6: G = G::from_u64(5); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_10]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_10]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(6); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_10]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_10]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_8]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_8]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_8]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_8]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31257,15 +31276,15 @@ fn aiur_fn_333( }) } -const INPUT_SIZE_334: usize = 2; -const IN_334: usize = 2; -const OUT_334: usize = 1; -fn aiur_fn_334( - inp: [G; IN_334], +const INPUT_SIZE_335: usize = 2; +const IN_335: usize = 2; +const OUT_335: usize = 1; +fn aiur_fn_335( + inp: [G; IN_335], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_334], ExecError> { +) -> Result<[G; OUT_335], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31296,14 +31315,14 @@ fn aiur_fn_334( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_334] = [__v_22]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_22]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_334] = [__v_22]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_22]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31323,25 +31342,25 @@ fn aiur_fn_334( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_334] = [__v_22]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_22]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_12(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } } else { aiur_fn_12(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_23]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_23]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_334] = [__v_23]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_23]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31361,15 +31380,15 @@ fn aiur_fn_334( }) } -const INPUT_SIZE_335: usize = 2; -const IN_335: usize = 2; -const OUT_335: usize = 1; -fn aiur_fn_335( - inp: [G; IN_335], +const INPUT_SIZE_336: usize = 2; +const IN_336: usize = 2; +const OUT_336: usize = 1; +fn aiur_fn_336( + inp: [G; IN_336], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_335], ExecError> { +) -> Result<[G; OUT_336], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31386,14 +31405,14 @@ fn aiur_fn_335( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_335] = [__v_8]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_8]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_335] = [__v_8]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_8]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31406,24 +31425,24 @@ fn aiur_fn_335( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_335] = [__v_8]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_8]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = (__v_3 - __v_6); match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_335] = [__v_9]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_9]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_335] = [__v_9]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_9]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31440,15 +31459,15 @@ fn aiur_fn_335( }) } -const INPUT_SIZE_336: usize = 4; -const IN_336: usize = 4; -const OUT_336: usize = 1; -fn aiur_fn_336( - inp: [G; IN_336], +const INPUT_SIZE_337: usize = 4; +const IN_337: usize = 4; +const OUT_337: usize = 1; +fn aiur_fn_337( + inp: [G; IN_337], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_336], ExecError> { +) -> Result<[G; OUT_337], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31458,16 +31477,16 @@ fn aiur_fn_336( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_336] = [__v_4]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_4]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_336] = [__v_4]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_4]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31475,16 +31494,16 @@ fn aiur_fn_336( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_336] = [__v_4]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_4]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_336] = [__v_4]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_4]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31496,15 +31515,15 @@ fn aiur_fn_336( }) } -const INPUT_SIZE_337: usize = 1; -const IN_337: usize = 1; -const OUT_337: usize = 1; -fn aiur_fn_337( - inp: [G; IN_337], +const INPUT_SIZE_338: usize = 1; +const IN_338: usize = 1; +const OUT_338: usize = 1; +fn aiur_fn_338( + inp: [G; IN_338], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_337], ExecError> { +) -> Result<[G; OUT_338], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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 }; @@ -31516,77 +31535,77 @@ fn aiur_fn_337( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 + __v_5); - let __ret: [G; OUT_337] = [__v_6]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_6]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_337] = [__v_5]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_5]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_337] = [__v_5]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_5]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_337] = [__v_5]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_5]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_337] = [__v_7]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_7]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_337] = [__v_8]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_8]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_337] = [__v_8]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_8]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_337] = [__v_5]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_5]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_337] = [__v_5]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_5]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31596,59 +31615,59 @@ fn aiur_fn_337( }) } -const INPUT_SIZE_338: usize = 3; -const IN_338: usize = 3; -const OUT_338: usize = 1; -fn aiur_fn_338( - inp: [G; IN_338], +const INPUT_SIZE_339: usize = 3; +const IN_339: usize = 3; +const OUT_339: usize = 1; +fn aiur_fn_339( + inp: [G; IN_339], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_338], ExecError> { +) -> Result<[G; OUT_339], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_338] = [__v_8]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_8]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_339: usize = 2; -const IN_339: usize = 2; -const OUT_339: usize = 1; -fn aiur_fn_339( - inp: [G; IN_339], +const INPUT_SIZE_340: usize = 2; +const IN_340: usize = 2; +const OUT_340: usize = 1; +fn aiur_fn_340( + inp: [G; IN_340], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_339], ExecError> { +) -> Result<[G; OUT_340], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_339] = [__v_1]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_1]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_339] = [__v_0]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_0]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31658,57 +31677,57 @@ fn aiur_fn_339( }) } -const INPUT_SIZE_340: usize = 1; -const IN_340: usize = 1; -const OUT_340: usize = 1; -fn aiur_fn_340( - inp: [G; IN_340], +const INPUT_SIZE_341: usize = 1; +const IN_341: usize = 1; +const OUT_341: usize = 1; +fn aiur_fn_341( + inp: [G; IN_341], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_340], ExecError> { +) -> Result<[G; OUT_341], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_340] = [__v_1]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_1]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 - __v_1); - let __ret: [G; OUT_340] = [__v_2]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_2]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_341: usize = 2; -const IN_341: usize = 2; -const OUT_341: usize = 1; -fn aiur_fn_341( - inp: [G; IN_341], +const INPUT_SIZE_342: usize = 2; +const IN_342: usize = 2; +const OUT_342: usize = 1; +fn aiur_fn_342( + inp: [G; IN_342], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_341], ExecError> { +) -> Result<[G; OUT_342], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_341] = [__v_0]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_342] = [__v_0]; + if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_341] = [__v_1]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_342] = [__v_1]; + if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31718,25 +31737,6 @@ fn aiur_fn_341( }) } -const INPUT_SIZE_342: usize = 2; -const IN_342: usize = 2; -const OUT_342: usize = 1; -fn aiur_fn_342( - inp: [G; IN_342], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_342], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __ret: [G; OUT_342] = [__v_2]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - const INPUT_SIZE_343: usize = 3; const IN_343: usize = 3; const OUT_343: usize = 1; @@ -31963,7 +31963,7 @@ fn aiur_fn_346( let __v_1: G = inp[1]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; @@ -32030,7 +32030,7 @@ fn aiur_fn_348( match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -32129,7 +32129,7 @@ fn aiur_fn_350( 1u64 => { let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -32160,11 +32160,11 @@ fn aiur_fn_351( 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_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { @@ -32203,7 +32203,7 @@ fn aiur_fn_352( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_1]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -32246,7 +32246,7 @@ fn aiur_fn_352( let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_352] = [__v_8]; if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -32306,7 +32306,7 @@ fn aiur_fn_353( let __v_5: G = (__v_2 + __v_4); let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_353] = [__v_7]; if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -32332,13 +32332,13 @@ fn aiur_fn_354( let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_354] = [__v_10]; if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -32366,9 +32366,9 @@ fn aiur_fn_355( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { @@ -32595,9 +32595,9 @@ fn aiur_fn_359( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { @@ -32945,9 +32945,9 @@ fn aiur_fn_364( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { @@ -33111,7 +33111,7 @@ fn aiur_fn_366( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_2]; let __cu = unconstrained; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { @@ -33205,9 +33205,9 @@ fn aiur_fn_368( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { @@ -33262,7 +33262,7 @@ fn aiur_fn_369( let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_3]; let __cu = unconstrained; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { @@ -33514,7 +33514,7 @@ fn aiur_fn_373( let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_373] = [__v_10]; if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -33567,7 +33567,7 @@ fn aiur_fn_374( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; @@ -33610,7 +33610,7 @@ fn aiur_fn_374( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_374] = [__v_7]; if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -33637,9 +33637,9 @@ fn aiur_fn_375( let __v_4: G = inp[4]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_4]; let __cu = unconstrained; 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 __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; @@ -33690,7 +33690,7 @@ fn aiur_fn_375( _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_30]; if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -33701,7 +33701,7 @@ fn aiur_fn_375( _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_375] = [__v_17]; if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -34023,7 +34023,7 @@ fn aiur_fn_382( let __v_3: G = inp[3]; let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { @@ -34048,7 +34048,7 @@ fn aiur_fn_382( 2u64 => { let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __cu = unconstrained; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { @@ -34157,7 +34157,7 @@ fn aiur_fn_382( let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; let __ret: [G; OUT_382] = [__v_77, __v_78]; if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -34249,7 +34249,7 @@ fn aiur_fn_383( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __ret: [G; OUT_383] = [__v_5]; if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -34335,13 +34335,13 @@ fn aiur_fn_385( let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -34362,7 +34362,7 @@ fn aiur_fn_385( let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12]; let __cu = unconstrained; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -34371,11 +34371,11 @@ fn aiur_fn_385( let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_14]; let __cu = unconstrained; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_18]; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_17, __v_20]; if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -34415,7 +34415,7 @@ fn aiur_fn_385( let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12]; let __cu = unconstrained; 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_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -34424,13 +34424,13 @@ fn aiur_fn_385( let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_14]; let __cu = unconstrained; 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_18: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_385] = [__v_17, __v_21]; if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -34451,7 +34451,7 @@ fn aiur_fn_385( } }, _ => { - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __ret: [G; OUT_385] = [__v_9, __v_10]; @@ -34500,12 +34500,12 @@ fn aiur_fn_386( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; @@ -34540,9 +34540,9 @@ fn aiur_fn_387( ) -> Result<[G; OUT_387], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; 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_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { @@ -34550,9 +34550,9 @@ fn aiur_fn_387( break '__mc_0 [__v_3]; }, _ => { - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; 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_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { @@ -34560,9 +34560,9 @@ fn aiur_fn_387( break '__mc_0 [__v_5]; }, _ => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -34570,9 +34570,9 @@ fn aiur_fn_387( break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -34580,9 +34580,9 @@ fn aiur_fn_387( break '__mc_0 [__v_9]; }, _ => { - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; 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_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { @@ -34590,9 +34590,9 @@ fn aiur_fn_387( break '__mc_0 [__v_11]; }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; 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_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { @@ -34600,9 +34600,9 @@ fn aiur_fn_387( break '__mc_0 [__v_13]; }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { @@ -34610,9 +34610,9 @@ fn aiur_fn_387( break '__mc_0 [__v_15]; }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; 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_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { @@ -34620,9 +34620,9 @@ fn aiur_fn_387( break '__mc_0 [__v_17]; }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { @@ -34630,9 +34630,9 @@ fn aiur_fn_387( break '__mc_0 [__v_19]; }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; 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_19: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; 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_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { @@ -34640,9 +34640,9 @@ fn aiur_fn_387( break '__mc_0 [__v_21]; }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; 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_21: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; 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_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { @@ -34650,9 +34650,9 @@ fn aiur_fn_387( break '__mc_0 [__v_23]; }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; 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_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { @@ -34660,9 +34660,9 @@ fn aiur_fn_387( break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; 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_25: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; 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_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { @@ -34670,9 +34670,9 @@ fn aiur_fn_387( break '__mc_0 [__v_27]; }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; 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_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { @@ -34680,9 +34680,9 @@ fn aiur_fn_387( break '__mc_0 [__v_29]; }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; 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_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { @@ -34690,9 +34690,9 @@ fn aiur_fn_387( break '__mc_0 [__v_31]; }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; 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_31: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __cu = unconstrained; 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_32: G = __r_arr[0]; match __v_32.as_canonical_u64() { 1u64 => { @@ -34744,7 +34744,7 @@ fn aiur_fn_387( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { @@ -34754,7 +34754,7 @@ fn aiur_fn_387( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0]; let __cu = unconstrained; 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]; match __v_5.as_canonical_u64() { 1u64 => { @@ -34764,7 +34764,7 @@ fn aiur_fn_387( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -34784,7 +34784,7 @@ fn aiur_fn_387( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0]; let __cu = unconstrained; 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]; match __v_8.as_canonical_u64() { 1u64 => { @@ -34841,7 +34841,7 @@ fn aiur_fn_388( 2u64 => { let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_388] = [__v_6, __v_7]; @@ -34849,7 +34849,7 @@ fn aiur_fn_388( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; 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]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_388] = [__v_5, __v_6]; @@ -34857,7 +34857,7 @@ fn aiur_fn_388( return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_388] = [__v_5, __v_6]; @@ -34873,7 +34873,7 @@ fn aiur_fn_388( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_388] = [__v_5, __v_6]; @@ -34909,7 +34909,7 @@ fn aiur_fn_389( let __v_2: G = inp[2]; let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { @@ -34923,7 +34923,7 @@ fn aiur_fn_389( _ => { let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -34996,7 +34996,7 @@ fn aiur_fn_390( let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_390] = [__v_13, __v_17]; if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -35064,7 +35064,7 @@ fn aiur_fn_391( let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_391] = [__v_13, __v_17]; if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -35100,7 +35100,7 @@ fn aiur_fn_392( let __v_1: G = inp[1]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35112,7 +35112,7 @@ fn aiur_fn_392( 2u64 => { let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { @@ -35200,7 +35200,7 @@ fn aiur_fn_393( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -35229,7 +35229,7 @@ fn aiur_fn_393( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; @@ -35240,7 +35240,7 @@ fn aiur_fn_393( } }, 2u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_20]; if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -35259,7 +35259,7 @@ fn aiur_fn_393( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_22]; if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -35338,7 +35338,7 @@ fn aiur_fn_393( } }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_28]; if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -35349,7 +35349,7 @@ fn aiur_fn_393( } }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_393] = [__v_20]; if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -35404,7 +35404,7 @@ fn aiur_fn_394( let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_394] = [__v_14, __v_15]; if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -35630,12 +35630,12 @@ fn aiur_fn_396( 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; 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_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); @@ -35647,16 +35647,16 @@ fn aiur_fn_396( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3]; let __cu = unconstrained; 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_6: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_6]; let __cu = unconstrained; 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_7: G = __r_arr[0]; let __v_8: G = G::from_u64(7); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); @@ -35722,7 +35722,7 @@ fn aiur_fn_397( let __v_16: G = (__v_2 + __v_15); let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_16, __v_17]; let __cu = unconstrained; 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_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -35752,7 +35752,7 @@ fn aiur_fn_397( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_3 + __v_4); let __v_23: G = (__v_2 + __v_22); @@ -35762,9 +35762,9 @@ fn aiur_fn_397( let __v_26: G = (__v_16 + __v_25); let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; @@ -35812,7 +35812,7 @@ fn aiur_fn_398( let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35822,7 +35822,7 @@ fn aiur_fn_398( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_3]; let __cu = unconstrained; 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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { @@ -35832,7 +35832,7 @@ fn aiur_fn_398( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -35856,7 +35856,7 @@ fn aiur_fn_398( let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; @@ -35934,7 +35934,7 @@ fn aiur_fn_400( let __v_1: G = inp[1]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -35944,7 +35944,7 @@ fn aiur_fn_400( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -35961,7 +35961,7 @@ fn aiur_fn_400( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; @@ -36025,7 +36025,7 @@ fn aiur_fn_401( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -36038,11 +36038,11 @@ fn aiur_fn_401( _ => { let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; @@ -36057,7 +36057,7 @@ fn aiur_fn_401( let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_24, __v_9]; let __cu = unconstrained; 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_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); if (__v_29 != __v_30) { @@ -36068,14 +36068,14 @@ fn aiur_fn_401( let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __ret: [G; OUT_401] = [__v_32, __v_33]; if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = (__v_3 + __v_4); let __v_33: G = (__v_2 + __v_32); @@ -36090,11 +36090,11 @@ fn aiur_fn_401( let __v_39: G = (__v_12 + __v_38); let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(1); let __ret: [G; OUT_401] = [__v_44, __v_43]; @@ -36110,7 +36110,7 @@ fn aiur_fn_401( let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_401] = [__v_27, __v_28]; if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -36135,7 +36135,7 @@ fn aiur_fn_402( ) -> Result<[G; OUT_402], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -36145,7 +36145,7 @@ fn aiur_fn_402( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -36397,7 +36397,7 @@ fn aiur_fn_404( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -36438,9 +36438,9 @@ fn aiur_fn_404( let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_41, __v_42]; let __cu = unconstrained; 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_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { @@ -36470,13 +36470,13 @@ fn aiur_fn_404( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = (__v_3 + __v_4); let __v_48: G = (__v_47 + __v_5); let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; @@ -36486,7 +36486,7 @@ fn aiur_fn_404( let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __ret: [G; OUT_404] = [__v_56, __v_57]; if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -36571,7 +36571,7 @@ fn aiur_fn_405( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -36781,7 +36781,7 @@ fn aiur_fn_407( ) -> Result<[G; OUT_407], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -36829,7 +36829,7 @@ fn aiur_fn_408( 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_278] = { let __args: [G; IN_278] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -36882,7 +36882,7 @@ fn aiur_fn_408( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_408] = [__v_50]; if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -36929,7 +36929,7 @@ fn aiur_fn_409( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -37226,7 +37226,7 @@ fn aiur_fn_413( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { @@ -37295,7 +37295,7 @@ fn aiur_fn_414( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -37382,7 +37382,7 @@ fn aiur_fn_416( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -37416,7 +37416,7 @@ fn aiur_fn_417( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; @@ -37439,7 +37439,7 @@ fn aiur_fn_417( let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_14]; if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -37495,7 +37495,7 @@ fn aiur_fn_417( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_417] = [__v_7]; if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -37523,7 +37523,7 @@ fn aiur_fn_418( let __v_5: G = inp[5]; let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -37560,7 +37560,7 @@ fn aiur_fn_418( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_418] = [__v_26]; if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -37569,7 +37569,7 @@ fn aiur_fn_418( } }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_418] = [__v_13]; if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -37594,7 +37594,7 @@ fn aiur_fn_419( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -37625,7 +37625,7 @@ fn aiur_fn_419( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_419] = [__v_21]; if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -37634,7 +37634,7 @@ fn aiur_fn_419( } }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __ret: [G; OUT_419] = [__v_18]; if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -37688,7 +37688,7 @@ fn aiur_fn_420( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -37748,7 +37748,7 @@ fn aiur_fn_422( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; @@ -37791,7 +37791,7 @@ fn aiur_fn_422( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_422] = [__v_7]; if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -37825,7 +37825,7 @@ fn aiur_fn_423( let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_423] = [__v_10]; if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -37875,9 +37875,9 @@ fn aiur_fn_424( let __v_4: G = inp[4]; let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_4]; let __cu = unconstrained; 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 __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; @@ -37928,7 +37928,7 @@ fn aiur_fn_424( _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_30]; if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -37939,7 +37939,7 @@ fn aiur_fn_424( _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_424] = [__v_17]; if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -37970,9 +37970,9 @@ fn aiur_fn_425( let __v_5: G = __r_arr[0]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { @@ -38015,7 +38015,7 @@ fn aiur_fn_425( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38044,7 +38044,7 @@ fn aiur_fn_425( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_23]; if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -38065,7 +38065,7 @@ fn aiur_fn_425( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_23]; if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -38144,7 +38144,7 @@ fn aiur_fn_425( } }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_29]; if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -38155,7 +38155,7 @@ fn aiur_fn_425( } }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_425] = [__v_21]; if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -38344,7 +38344,7 @@ fn aiur_fn_429( 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_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -38371,7 +38371,7 @@ fn aiur_fn_429( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -38380,7 +38380,7 @@ fn aiur_fn_429( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -38404,7 +38404,7 @@ fn aiur_fn_429( if (__v_23 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_429] = [__v_24]; if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -38471,7 +38471,7 @@ fn aiur_fn_429( let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -38506,7 +38506,7 @@ fn aiur_fn_429( }, 1u64 => { let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; 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_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); @@ -38527,7 +38527,7 @@ fn aiur_fn_429( let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -38537,7 +38537,7 @@ fn aiur_fn_429( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -38558,7 +38558,7 @@ fn aiur_fn_429( match __v_17.as_canonical_u64() { 5u64 => { let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; @@ -38579,7 +38579,7 @@ fn aiur_fn_429( } match __v_31.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; @@ -38647,7 +38647,7 @@ fn aiur_fn_430( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -38656,7 +38656,7 @@ fn aiur_fn_430( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -38680,7 +38680,7 @@ fn aiur_fn_430( if (__v_21 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_430] = [__v_22]; if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -38747,7 +38747,7 @@ fn aiur_fn_430( let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -38782,7 +38782,7 @@ fn aiur_fn_430( }, 1u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; 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_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); @@ -38803,7 +38803,7 @@ fn aiur_fn_430( let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -38813,7 +38813,7 @@ fn aiur_fn_430( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -38834,7 +38834,7 @@ fn aiur_fn_430( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; @@ -38855,7 +38855,7 @@ fn aiur_fn_430( } match __v_29.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; @@ -39096,7 +39096,7 @@ fn aiur_fn_434( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { @@ -39148,11 +39148,11 @@ fn aiur_fn_435( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { @@ -39198,11 +39198,11 @@ fn aiur_fn_436( let __v_6: G = G::from_u64(0); let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { @@ -39315,10 +39315,10 @@ fn aiur_fn_439( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -39498,7 +39498,7 @@ fn aiur_fn_441( 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; 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_5: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_5]; if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -39513,9 +39513,9 @@ fn aiur_fn_441( } }, 2u64 => { - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; let __ret: [G; OUT_441] = [__v_6]; if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -39555,7 +39555,7 @@ fn aiur_fn_442( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __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 __ret: [G; OUT_442] = [__v_5, __v_9, __v_3]; if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -39580,9 +39580,9 @@ fn aiur_fn_442( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { @@ -39591,7 +39591,7 @@ fn aiur_fn_442( let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13]; let __cu = unconstrained; 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_15: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_14, __v_12, __v_15]; if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -39616,9 +39616,9 @@ fn aiur_fn_442( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; 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_13: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_13]; let __cu = unconstrained; 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_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { @@ -39638,7 +39638,7 @@ fn aiur_fn_442( match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_21, __v_17]; let __cu = unconstrained; 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_23: G = __r_arr[0]; let __ret: [G; OUT_442] = [__v_22, __v_20, __v_23]; if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -39765,7 +39765,7 @@ fn aiur_fn_443( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { @@ -39846,9 +39846,9 @@ fn aiur_fn_445( 7u64 => { match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_5]; let __cu = unconstrained; 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_7: G = __r_arr[0]; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_2]; let __cu = unconstrained; 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 __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -40069,7 +40069,7 @@ fn aiur_fn_449( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_449] = [__v_11]; if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -40336,10 +40336,10 @@ fn aiur_fn_452( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; @@ -40373,7 +40373,7 @@ fn aiur_fn_452( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_16]; let __cu = unconstrained; 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_19: G = __r_arr[0]; let __v_20: G = (__v_13 - __v_17); let __v_21: G = G::from_bool((__v_20 == G::ZERO)); @@ -40606,7 +40606,7 @@ fn aiur_fn_455( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_455] = [__v_13, __v_2]; if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -40630,7 +40630,7 @@ fn aiur_fn_455( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_10]; let __cu = unconstrained; 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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { @@ -40786,7 +40786,7 @@ fn aiur_fn_455( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_455] = [__v_13, __v_2]; if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -40810,7 +40810,7 @@ fn aiur_fn_455( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_10]; let __cu = unconstrained; 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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { @@ -41065,7 +41065,7 @@ fn aiur_fn_458( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -41075,7 +41075,7 @@ fn aiur_fn_458( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -41098,7 +41098,7 @@ fn aiur_fn_458( let __v_24: G = (__v_22 - __v_23); match __v_24.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; @@ -41268,7 +41268,7 @@ fn aiur_fn_460( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -41291,9 +41291,9 @@ fn aiur_fn_460( let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; 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_24: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_24]; let __cu = unconstrained; 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 __v_25: G = __r_arr[0]; let __ret: [G; OUT_460] = [__v_25]; if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -41418,7 +41418,7 @@ fn aiur_fn_463( ) -> Result<[G; OUT_463], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -41428,7 +41428,7 @@ fn aiur_fn_463( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -41452,7 +41452,7 @@ fn aiur_fn_463( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -41655,7 +41655,7 @@ fn aiur_fn_466( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_466] = [__v_11]; if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -41751,7 +41751,7 @@ fn aiur_fn_468( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_11]; if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -41773,7 +41773,7 @@ fn aiur_fn_468( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -41936,7 +41936,7 @@ fn aiur_fn_468( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_468] = [__v_11]; if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -41972,7 +41972,7 @@ fn aiur_fn_468( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -42172,7 +42172,7 @@ fn aiur_fn_471( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -42187,7 +42187,7 @@ fn aiur_fn_471( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -42453,7 +42453,7 @@ fn aiur_fn_475( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -42538,7 +42538,7 @@ fn aiur_fn_476( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -42721,7 +42721,7 @@ fn aiur_fn_479( 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_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -42733,7 +42733,7 @@ fn aiur_fn_479( 8u64 => { let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -42751,7 +42751,7 @@ fn aiur_fn_479( let __v_17: G = G::from_u64(8); let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_479] = [__v_19, __v_20]; if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -42794,7 +42794,7 @@ fn aiur_fn_480( ) -> Result<[G; OUT_480], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -42804,7 +42804,7 @@ fn aiur_fn_480( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -42821,20 +42821,20 @@ fn aiur_fn_480( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_480] = [__v_21, __v_22]; if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_480] = [__v_21, __v_22]; if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -42893,7 +42893,7 @@ fn aiur_fn_481( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -42908,7 +42908,7 @@ fn aiur_fn_481( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -42987,7 +42987,7 @@ fn aiur_fn_482( ) -> Result<[G; OUT_482], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -43134,7 +43134,7 @@ fn aiur_fn_484( 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_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 0u64 => { @@ -43176,7 +43176,7 @@ fn aiur_fn_485( let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { @@ -43245,7 +43245,7 @@ fn aiur_fn_486( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -43254,7 +43254,7 @@ fn aiur_fn_486( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -43278,14 +43278,14 @@ fn aiur_fn_486( if (__v_20 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_486] = [__v_22]; if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; @@ -43321,7 +43321,7 @@ fn aiur_fn_486( let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -43512,7 +43512,7 @@ fn aiur_fn_488( }, 1u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; 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_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); @@ -43544,7 +43544,7 @@ fn aiur_fn_489( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -43558,7 +43558,7 @@ fn aiur_fn_489( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_489] = [__v_13]; if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -43648,7 +43648,7 @@ fn aiur_fn_491( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { @@ -43688,7 +43688,7 @@ fn aiur_fn_492( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -43697,7 +43697,7 @@ fn aiur_fn_492( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); if (__v_9 != __v_10) { @@ -43787,7 +43787,7 @@ fn aiur_fn_494( let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -43797,7 +43797,7 @@ fn aiur_fn_494( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -43818,7 +43818,7 @@ fn aiur_fn_494( match __v_13.as_canonical_u64() { 5u64 => { let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -43839,7 +43839,7 @@ fn aiur_fn_494( } match __v_27.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; @@ -44630,7 +44630,7 @@ fn aiur_fn_511( let __v_0: G = inp[0]; let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { @@ -44642,7 +44642,7 @@ fn aiur_fn_511( _ => { let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { @@ -44654,7 +44654,7 @@ fn aiur_fn_511( _ => { let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -44666,7 +44666,7 @@ fn aiur_fn_511( _ => { let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -44678,7 +44678,7 @@ fn aiur_fn_511( _ => { let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { @@ -44690,7 +44690,7 @@ fn aiur_fn_511( _ => { let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { @@ -44732,7 +44732,7 @@ fn aiur_fn_512( let __v_0: G = inp[0]; let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { @@ -44744,7 +44744,7 @@ fn aiur_fn_512( _ => { let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { @@ -44756,7 +44756,7 @@ fn aiur_fn_512( _ => { let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -44804,13 +44804,13 @@ fn aiur_fn_513( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; 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_12: G = __r_arr[0]; let __v_13: G = (__v_10 + __v_12); match __v_13.as_canonical_u64() { @@ -44905,12 +44905,12 @@ fn aiur_fn_514( let __v_1: G = inp[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, _ => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; 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_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, @@ -45066,7 +45066,7 @@ fn aiur_fn_516( let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_516] = [__v_27, __v_28]; if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -45142,15 +45142,15 @@ fn aiur_fn_517( _ => { let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; 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_9: G = __r_arr[0]; let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __cu = unconstrained; 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_11: G = __r_arr[0]; let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __cu = unconstrained; 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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { @@ -45198,7 +45198,7 @@ fn aiur_fn_518( let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_7]; let __cu = unconstrained; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -45213,9 +45213,9 @@ fn aiur_fn_518( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9]; let __cu = unconstrained; 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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10]; let __cu = unconstrained; 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_11: G = __r_arr[0]; let __v_12: G = G::from_u64(2); let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; @@ -45232,7 +45232,7 @@ fn aiur_fn_518( let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __ret: [G; OUT_518] = [__v_24, __v_25]; if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -45271,7 +45271,7 @@ fn aiur_fn_519( let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_10]; let __cu = unconstrained; 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_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -45286,7 +45286,7 @@ fn aiur_fn_519( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_11]; let __cu = unconstrained; 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_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { @@ -45303,12 +45303,12 @@ fn aiur_fn_519( 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __v_15]; let __cu = unconstrained; 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_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, _ => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, @@ -45394,12 +45394,12 @@ fn aiur_fn_520( let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; 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_34: G = __r_arr[0]; break '__mc_0 [__v_34]; }, _ => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; 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_34: G = __r_arr[0]; break '__mc_0 [__v_34]; }, @@ -45529,7 +45529,7 @@ fn aiur_fn_521( 7u64 => { match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -45635,7 +45635,7 @@ fn aiur_fn_522( let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; 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_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); @@ -45661,13 +45661,13 @@ fn aiur_fn_522( let __v_42: G = G::from_u64(2); let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; @@ -45707,7 +45707,7 @@ fn aiur_fn_522( let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __ret: [G; OUT_522] = [__v_69, __v_70]; if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -45753,13 +45753,13 @@ fn aiur_fn_523( let __v_10: G = G::from_u64(2); let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; @@ -45797,7 +45797,7 @@ fn aiur_fn_523( let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __ret: [G; OUT_523] = [__v_36, __v_37]; if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -46163,7 +46163,7 @@ fn aiur_fn_533( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; 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_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -46202,7 +46202,7 @@ fn aiur_fn_534( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; 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_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { @@ -46588,9 +46588,9 @@ fn aiur_fn_538( 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_118] = { let __args: [G; IN_118] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; let __cu = unconstrained; 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_2: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1]; let __cu = unconstrained; 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_3: G = __r_arr[0]; let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; @@ -47831,7 +47831,7 @@ fn aiur_fn_549( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -47846,7 +47846,7 @@ fn aiur_fn_549( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; @@ -48006,7 +48006,7 @@ fn aiur_fn_551( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(4); - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -48015,7 +48015,7 @@ fn aiur_fn_551( let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -48037,9 +48037,9 @@ fn aiur_fn_551( let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __cu = unconstrained; 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 __v_34: G = __r_arr[0]; let __ret: [G; OUT_551] = [__v_34]; if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -48061,7 +48061,7 @@ fn aiur_fn_552( let __v_1: G = inp[1]; let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -48792,7 +48792,7 @@ fn aiur_fn_566( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { @@ -49127,7 +49127,7 @@ fn aiur_fn_571( ) -> Result<[G; OUT_571], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -49205,7 +49205,7 @@ fn aiur_fn_571( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(0); let __v_62: G = G::from_u64(1); @@ -49226,7 +49226,7 @@ fn aiur_fn_571( } let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = G::from_u64(1); if (__v_73 != __v_74) { @@ -49362,7 +49362,7 @@ fn aiur_fn_573( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -49612,7 +49612,7 @@ fn aiur_fn_577( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -49833,7 +49833,7 @@ fn aiur_fn_580( let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(201); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; @@ -49891,7 +49891,7 @@ fn aiur_fn_581( 0u64 => { let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -49904,7 +49904,7 @@ fn aiur_fn_581( 1u64 => { let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -49918,7 +49918,7 @@ fn aiur_fn_581( let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -49931,7 +49931,7 @@ fn aiur_fn_581( 3u64 => { let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; 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_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -50147,7 +50147,7 @@ fn aiur_fn_585( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -50164,7 +50164,7 @@ fn aiur_fn_585( let __v_15: G = __loaded[11]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_1]; let __cu = unconstrained; 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_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { @@ -50204,7 +50204,7 @@ fn aiur_fn_586( let __v_7: G = (__v_1 + __v_3); let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -50418,7 +50418,7 @@ fn aiur_fn_590( 5u64 => { let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { @@ -50535,7 +50535,7 @@ fn aiur_fn_593( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __ret: [G; OUT_593] = [__v_2]; if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -50567,7 +50567,7 @@ fn aiur_fn_594( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_1]; let __cu = unconstrained; 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_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { @@ -50604,7 +50604,7 @@ fn aiur_fn_595( 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_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -50957,7 +50957,7 @@ fn aiur_fn_600( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -51049,7 +51049,7 @@ fn aiur_fn_601( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -51080,7 +51080,7 @@ fn aiur_fn_601( } }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; @@ -51160,7 +51160,7 @@ fn aiur_fn_602( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -51335,7 +51335,7 @@ fn aiur_fn_606( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -51368,7 +51368,7 @@ fn aiur_fn_606( }, } }; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_15, __v_5]; let __cu = unconstrained; 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_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); if (__v_24 != __v_25) { @@ -51462,7 +51462,7 @@ fn aiur_fn_608( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_12]; let __cu = unconstrained; 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_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { @@ -51471,7 +51471,7 @@ fn aiur_fn_608( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -51636,7 +51636,7 @@ fn aiur_fn_609( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; @@ -51669,7 +51669,7 @@ fn aiur_fn_609( if (__v_60 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) }); } - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = G::from_u64(1); if (__v_79 != __v_80) { @@ -51737,7 +51737,7 @@ fn aiur_fn_610( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { @@ -51890,7 +51890,7 @@ fn aiur_fn_612( let __v_5: G = (__v_1 - __v_2); match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; @@ -51913,7 +51913,7 @@ fn aiur_fn_612( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_11 - __v_15); let __v_17: G = G::from_u64(1); @@ -52110,7 +52110,7 @@ fn aiur_fn_615( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 0u64 => { @@ -52123,7 +52123,7 @@ fn aiur_fn_615( match __v_5.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -52187,7 +52187,7 @@ fn aiur_fn_616( 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_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { @@ -52197,7 +52197,7 @@ fn aiur_fn_616( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -52282,7 +52282,7 @@ fn aiur_fn_617( ) -> Result<[G; OUT_617], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -52483,7 +52483,7 @@ fn aiur_fn_619( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -52545,7 +52545,7 @@ fn aiur_fn_620( let __v_19: G = __loaded[3]; match __v_16.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -52619,7 +52619,7 @@ fn aiur_fn_621( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; @@ -52744,7 +52744,7 @@ fn aiur_fn_624( 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_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -52805,7 +52805,7 @@ fn aiur_fn_624( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_51: G = __loaded[0]; @@ -52929,9 +52929,9 @@ fn aiur_fn_625( 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; @@ -53022,7 +53022,7 @@ fn aiur_fn_626( 0u64 => { match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_1]; let __cu = unconstrained; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -53136,7 +53136,7 @@ fn aiur_fn_627( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_627] = [__v_11]; if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -53158,7 +53158,7 @@ fn aiur_fn_627( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -53340,7 +53340,7 @@ fn aiur_fn_627( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_627] = [__v_11]; if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -53362,7 +53362,7 @@ fn aiur_fn_627( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; 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_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -53458,7 +53458,7 @@ fn aiur_fn_628( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -53623,7 +53623,7 @@ fn aiur_fn_631( 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_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -53766,9 +53766,9 @@ fn aiur_fn_632( 0u64 => { match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; @@ -53787,7 +53787,7 @@ fn aiur_fn_632( 7u64 => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_68: G = __loaded[0]; @@ -53853,7 +53853,7 @@ fn aiur_fn_633( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -53919,7 +53919,7 @@ fn aiur_fn_633( } }; let __v_51: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -53978,7 +53978,7 @@ fn aiur_fn_633( break '__mc_1 [__v_101]; }, _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_101: G = __loaded[0]; @@ -54055,7 +54055,7 @@ fn aiur_fn_634( let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -54200,9 +54200,9 @@ fn aiur_fn_635( 0u64 => { match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_56: G = __loaded[0]; @@ -54221,7 +54221,7 @@ fn aiur_fn_635( 7u64 => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; @@ -54238,7 +54238,7 @@ fn aiur_fn_635( let __v_81: G = __loaded[11]; match __v_70.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_77, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_77, __v_3]; let __cu = unconstrained; 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_82: G = __r_arr[0]; match __v_82.as_canonical_u64() { 1u64 => { @@ -54366,7 +54366,7 @@ fn aiur_fn_636( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_1]; let __cu = unconstrained; 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_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -54425,7 +54425,7 @@ fn aiur_fn_637( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; let __cu = unconstrained; 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_11: G = __r_arr[0]; let __v_12: G = (__v_2 - __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_12.as_canonical_u64() { @@ -55185,7 +55185,7 @@ fn aiur_fn_651( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; @@ -55354,7 +55354,7 @@ fn aiur_fn_655( let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -55414,7 +55414,7 @@ fn aiur_fn_656( let __v_12: G = G::from_u64(0); let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; @@ -55430,7 +55430,7 @@ fn aiur_fn_656( let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -55447,7 +55447,7 @@ fn aiur_fn_656( let __v_36: G = __loaded[11]; match __v_25.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; @@ -55570,7 +55570,7 @@ fn aiur_fn_657( let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; @@ -55658,7 +55658,7 @@ fn aiur_fn_657( let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(1); - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_20]; let __cu = unconstrained; 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_55: G = __r_arr[0]; let __v_56: G = (__v_54 - __v_55); let __v_57: G = (__v_53 * __v_56); @@ -55829,7 +55829,7 @@ fn aiur_fn_659( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -55909,7 +55909,7 @@ fn aiur_fn_660( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -55987,7 +55987,7 @@ fn aiur_fn_661( 0u64 => { match __v_10.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -56195,12 +56195,12 @@ fn aiur_fn_662( let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = G::from_u64(1); let __v_93: G = (__v_9 - __v_92); @@ -56258,7 +56258,7 @@ fn aiur_fn_663( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -56370,7 +56370,7 @@ fn aiur_fn_665( let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -56516,9 +56516,9 @@ fn aiur_fn_666( 0u64 => { match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; @@ -56537,7 +56537,7 @@ fn aiur_fn_666( 7u64 => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_71: G = __loaded[0]; @@ -56563,7 +56563,7 @@ fn aiur_fn_666( } }; let __v_83: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_69, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_69, __v_3]; let __cu = unconstrained; 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_84: G = __r_arr[0]; match __v_84.as_canonical_u64() { 1u64 => { @@ -56657,7 +56657,7 @@ fn aiur_fn_667( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -56711,7 +56711,7 @@ fn aiur_fn_668( let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -56720,7 +56720,7 @@ fn aiur_fn_668( let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -56743,9 +56743,9 @@ fn aiur_fn_668( let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; 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_33: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __cu = unconstrained; 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 __v_34: G = __r_arr[0]; let __ret: [G; OUT_668] = [__v_34]; if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -56789,7 +56789,7 @@ fn aiur_fn_669( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -56891,7 +56891,7 @@ fn aiur_fn_671( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -57145,7 +57145,7 @@ fn aiur_fn_675( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_9 + __v_10); let __v_15: G = (__v_8 + __v_14); @@ -57174,7 +57174,7 @@ fn aiur_fn_675( let __v_34: G = __r_arr[0]; let __v_35: G = (__v_33 + __v_34); let __v_36: G = (__v_15 + __v_35); - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; @@ -57189,7 +57189,7 @@ fn aiur_fn_675( let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(2); let __v_51: G = G::from_u64(0); @@ -57343,7 +57343,7 @@ fn aiur_fn_678( let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; @@ -57351,7 +57351,7 @@ fn aiur_fn_678( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); @@ -57562,7 +57562,7 @@ fn aiur_fn_683( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -57624,7 +57624,7 @@ fn aiur_fn_684( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; let __cu = unconstrained; 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_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { @@ -57843,7 +57843,7 @@ fn aiur_fn_687( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -57918,7 +57918,7 @@ fn aiur_fn_688( 7u64 => { let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -57940,7 +57940,7 @@ fn aiur_fn_688( let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_22]; let __cu = unconstrained; 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_30: G = __r_arr[0]; let __v_31: G = (__v_29 - __v_30); let __v_32: G = (__v_28 * __v_31); @@ -58028,7 +58028,7 @@ fn aiur_fn_689( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; @@ -58258,7 +58258,7 @@ fn aiur_fn_693( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { @@ -58331,7 +58331,7 @@ fn aiur_fn_693( let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -58415,7 +58415,7 @@ fn aiur_fn_694( ) -> Result<[G; OUT_694], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -58470,7 +58470,7 @@ fn aiur_fn_695( match __v_1.as_canonical_u64() { 2u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); @@ -58482,7 +58482,7 @@ fn aiur_fn_695( }, 4u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_17(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; @@ -59067,7 +59067,7 @@ fn aiur_fn_702( ) -> Result<[G; OUT_702], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -59370,9 +59370,9 @@ fn aiur_fn_705( let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_50: G = __loaded[0]; @@ -59408,12 +59408,12 @@ fn aiur_fn_706( let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_3]; 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_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_7]; 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 __v_8: G = __r_arr[0]; let __ret: [G; OUT_706] = [__v_8]; if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -59436,14 +59436,14 @@ fn aiur_fn_707( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_1, __v_4]; 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_5: G = __r_arr[0]; - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_5]; let __cu = unconstrained; 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_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_9]; 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 __v_10: G = __r_arr[0]; let __ret: [G; OUT_707] = [__v_10]; if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -59462,12 +59462,12 @@ fn aiur_fn_708( ) -> Result<[G; OUT_708], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; @@ -59595,9 +59595,9 @@ fn aiur_fn_709( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; 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 { 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_37: G = __r_arr[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_37]; let __cu = unconstrained; 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 __v_40: G = __r_arr[2]; @@ -59898,7 +59898,7 @@ fn aiur_fn_712( }, } }; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -60191,7 +60191,7 @@ fn aiur_fn_716( ) -> Result<[G; OUT_716], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -60203,7 +60203,7 @@ fn aiur_fn_716( return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; let __cu = unconstrained; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); @@ -60239,7 +60239,7 @@ fn aiur_fn_717( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; let __cu = unconstrained; 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 __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -60279,7 +60279,7 @@ fn aiur_fn_718( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_1]; let __cu = unconstrained; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); @@ -60312,7 +60312,7 @@ fn aiur_fn_719( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained; 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 __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); @@ -60345,7 +60345,7 @@ fn aiur_fn_720( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained; 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 __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { @@ -60400,7 +60400,7 @@ fn aiur_fn_721( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; let __cu = unconstrained; 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 __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { @@ -60460,7 +60460,7 @@ fn aiur_fn_722( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -60472,7 +60472,7 @@ fn aiur_fn_722( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -60491,7 +60491,7 @@ fn aiur_fn_722( let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -60534,7 +60534,7 @@ fn aiur_fn_723( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; let __cu = unconstrained; 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 __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -60567,7 +60567,7 @@ fn aiur_fn_724( ) -> Result<[G; OUT_724], 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_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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -60655,7 +60655,7 @@ fn aiur_fn_725( ) -> Result<[G; OUT_725], 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_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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -60732,7 +60732,7 @@ fn aiur_fn_726( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -60794,7 +60794,7 @@ fn aiur_fn_726( let __v_56: G = __r_arr[46]; let __v_57: G = __r_arr[47]; let __v_58: G = __r_arr[48]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; @@ -60837,7 +60837,7 @@ fn aiur_fn_727( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; let __cu = unconstrained; 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 __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -60870,10 +60870,10 @@ fn aiur_fn_728( ) -> Result<[G; OUT_728], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; 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 __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -61083,7 +61083,7 @@ fn aiur_fn_729( ) -> Result<[G; OUT_729], 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_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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -61174,7 +61174,7 @@ fn aiur_fn_730( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { @@ -61250,7 +61250,7 @@ fn aiur_fn_730( let __v_70: G = __r_arr[60]; let __v_71: G = __r_arr[61]; let __v_72: G = __r_arr[62]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; let __v_75: G = __r_arr[2]; @@ -61283,10 +61283,10 @@ fn aiur_fn_731( ) -> Result<[G; OUT_731], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; 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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; let __cu = unconstrained; 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 __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -61586,7 +61586,7 @@ fn aiur_fn_731( break '__mc_0 [__v_30, __v_11]; }, 1u64 => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_11]; let __cu = unconstrained; 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 __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -61654,9 +61654,9 @@ fn aiur_fn_732( let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; 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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_22]; let __cu = unconstrained; 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 __v_23: G = __r_arr[0]; let __ret: [G; OUT_732] = [__v_23]; if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -61797,9 +61797,9 @@ fn aiur_fn_736( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed quotient kind != real".to_string()) }); @@ -62440,7 +62440,7 @@ fn aiur_fn_741( if (__v_37 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) }); } - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -63132,7 +63132,7 @@ fn aiur_fn_748( let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -63412,7 +63412,7 @@ fn aiur_fn_750( let __v_9: G = __io_pair.0; let __v_10: G = __io_pair.1; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_9, __v_10]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_11, __v_9, __v_10]; let __cu = true; 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 { 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_12: G = __r_arr[0]; let __v_13: G = G::from_u64(103); let __v_14: G = G::from_u64(230); @@ -63464,9 +63464,9 @@ fn aiur_fn_750( let __v_60: G = G::from_u64(1); let __v_61: G = G::from_u64(1); let __v_62: G = { let __values: [G; 34] = [__v_60, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; 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_63: G = __r_arr[0]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_63]; let __cu = unconstrained; 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_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -63499,7 +63499,7 @@ fn aiur_fn_750( let __v_93: G = __r_arr[29]; let __v_94: G = __r_arr[30]; let __v_95: G = __r_arr[31]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_12]; let __cu = unconstrained; 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_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -63622,7 +63622,7 @@ fn aiur_fn_750( } match __v_97.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; let __cu = unconstrained; 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_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; @@ -63662,7 +63662,7 @@ fn aiur_fn_750( } }, 5u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; let __cu = unconstrained; 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_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; @@ -63675,7 +63675,7 @@ fn aiur_fn_750( return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; let __cu = unconstrained; 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_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; @@ -63740,10 +63740,10 @@ fn aiur_fn_750( return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; let __cu = unconstrained; 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_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_187]; let __cu = unconstrained; 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_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_186, __v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; @@ -63909,7 +63909,7 @@ fn aiur_fn_754( let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -64007,7 +64007,7 @@ fn aiur_fn_756( let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -64271,7 +64271,7 @@ fn aiur_fn_761( let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; @@ -64436,7 +64436,7 @@ fn aiur_fn_764( let __v_55: G = __loaded[46]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { @@ -64445,7 +64445,7 @@ fn aiur_fn_764( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -64599,7 +64599,7 @@ fn aiur_fn_765( let __v_53: G = __r_arr[5]; let __v_54: G = __r_arr[6]; let __v_55: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; let __v_58: G = __r_arr[2]; @@ -64666,7 +64666,7 @@ fn aiur_fn_766( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -64744,7 +64744,7 @@ fn aiur_fn_767( let __v_44: G = __loaded[35]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[5].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_5(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_5] = unsafe { *(result.output.as_ptr() as *const [G; OUT_5]) }; __ret } } else { aiur_fn_5(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { @@ -64753,7 +64753,7 @@ fn aiur_fn_767( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 051a10e1a..9887d66c4 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,25 @@ 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 __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __ret: [G; OUT_0] = [__v_2]; + if 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 = 3; +const IN_1: usize = 3; +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]; @@ -34,8 +53,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_1] = [__v_5]; + 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); }, _ => { @@ -43,29 +62,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_1] = { let __args: [G; IN_1] = [__v_0, __v_4, __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_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_1] = [__v_10]; + 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_1: usize = 8; -const IN_1: usize = 8; -const OUT_1: usize = 1; -fn aiur_fn_1( - inp: [G; IN_1], +const INPUT_SIZE_2: usize = 8; +const IN_2: usize = 8; +const OUT_2: usize = 1; +fn aiur_fn_2( + inp: [G; IN_2], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_1], ExecError> { +) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -92,85 +111,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_2] = [__v_8]; + 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_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_2] = [__v_8]; + 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_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_2] = [__v_8]; + 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_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_2] = [__v_8]; + 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_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_2] = [__v_8]; + 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_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_2] = [__v_8]; + 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_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_2] = [__v_8]; + 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_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_2] = [__v_8]; + 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_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_2] = [__v_8]; + 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_2: usize = 8; -const IN_2: usize = 8; -const OUT_2: usize = 4; -fn aiur_fn_2( - inp: [G; IN_2], +const INPUT_SIZE_3: usize = 8; +const IN_3: usize = 8; +const OUT_3: usize = 4; +fn aiur_fn_3( + inp: [G; IN_3], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_2], ExecError> { +) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -193,21 +212,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_3] = [__v_8, __v_9, __v_10, __v_11]; + 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_3: usize = 12; -const IN_3: usize = 12; -const OUT_3: usize = 4; -fn aiur_fn_3( - inp: [G; IN_3], +const INPUT_SIZE_4: usize = 12; +const IN_4: usize = 12; +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_3], 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]; @@ -240,21 +259,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_4] = [__v_12, __v_13, __v_14, __v_15]; + 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_4: usize = 8; -const IN_4: usize = 8; -const OUT_4: usize = 4; -fn aiur_fn_4( - inp: [G; IN_4], +const INPUT_SIZE_5: usize = 8; +const IN_5: usize = 8; +const OUT_5: usize = 4; +fn aiur_fn_5( + inp: [G; IN_5], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_4], 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]; @@ -268,27 +287,7 @@ 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)); }; - 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], - 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 __ret: [G; OUT_5] = [__v_2, __v_3, __v_0, __v_1]; + let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -308,14 +307,14 @@ fn aiur_fn_6( 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]; + let __ret: [G; OUT_6] = [__v_2, __v_3, __v_0, __v_1]; 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 = 8; -const IN_7: usize = 8; +const INPUT_SIZE_7: usize = 4; +const IN_7: usize = 4; const OUT_7: usize = 4; fn aiur_fn_7( inp: [G; IN_7], @@ -323,6 +322,26 @@ fn aiur_fn_7( 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_1, __v_2, __v_3, __v_0]; + 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 = 8; +const IN_8: usize = 8; +const OUT_8: usize = 4; +fn aiur_fn_8( + inp: [G; IN_8], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -348,21 +367,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_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)); }; 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_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_8], 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]; @@ -388,21 +407,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_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_9: usize = 8; -const IN_9: usize = 8; -const OUT_9: usize = 8; -fn aiur_fn_9( - inp: [G; IN_9], +const INPUT_SIZE_10: usize = 8; +const IN_10: usize = 8; +const OUT_10: usize = 8; +fn aiur_fn_10( + inp: [G; IN_10], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_9], ExecError> { +) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -436,8 +455,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_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + 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); }, _ => { @@ -450,8 +469,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_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; + 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); }, } @@ -465,8 +484,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_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; + 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); }, } @@ -479,8 +498,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_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; + 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); }, } @@ -492,8 +511,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_10] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; + 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); }, } @@ -504,8 +523,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_10] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; + 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); }, } @@ -515,8 +534,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_10] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; + 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); }, } @@ -525,8 +544,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_10] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + 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); }, } @@ -534,23 +553,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_10] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + 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_10: usize = 8; -const IN_10: usize = 8; -const OUT_10: usize = 1; -fn aiur_fn_10( - inp: [G; IN_10], +const INPUT_SIZE_11: usize = 8; +const IN_11: usize = 8; +const OUT_11: usize = 1; +fn aiur_fn_11( + inp: [G; IN_11], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_10], ExecError> { +) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -582,21 +601,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_11] = [__v_26]; + 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_11: usize = 8; -const IN_11: usize = 8; -const OUT_11: usize = 1; -fn aiur_fn_11( - inp: [G; IN_11], +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_11], 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]; @@ -627,21 +646,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_12] = [__v_28]; + 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_12: usize = 8; -const IN_12: usize = 8; -const OUT_12: usize = 1; -fn aiur_fn_12( - inp: [G; IN_12], +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_12], 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]; @@ -666,21 +685,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_13] = [__v_22]; + 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_13: usize = 1; -const IN_13: usize = 1; -const OUT_13: usize = 8; -fn aiur_fn_13( - inp: [G; IN_13], +const INPUT_SIZE_14: usize = 1; +const IN_14: usize = 1; +const OUT_14: usize = 8; +fn aiur_fn_14( + inp: [G; IN_14], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_13], ExecError> { +) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); @@ -739,21 +758,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_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + 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_14: usize = 1; -const IN_14: usize = 1; -const OUT_14: usize = 1; -fn aiur_fn_14( - inp: [G; IN_14], +const INPUT_SIZE_15: usize = 1; +const IN_15: usize = 1; +const OUT_15: usize = 1; +fn aiur_fn_15( + inp: [G; IN_15], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_14], ExecError> { +) -> Result<[G; OUT_15], 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 +789,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_15] = [__v_1]; + 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_15: usize = 4; -const IN_15: usize = 4; -const OUT_15: usize = 2; -fn aiur_fn_15( - inp: [G; IN_15], +const INPUT_SIZE_16: usize = 4; +const IN_16: usize = 4; +const OUT_16: usize = 2; +fn aiur_fn_16( + inp: [G; IN_16], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_15], ExecError> { +) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -792,21 +811,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_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)); }; 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_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_16], 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]; @@ -814,21 +833,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_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_17: usize = 2; -const IN_17: usize = 2; -const OUT_17: usize = 2; -fn aiur_fn_17( - inp: [G; IN_17], +const INPUT_SIZE_18: usize = 2; +const IN_18: usize = 2; +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_17], 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]; @@ -836,21 +855,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_18] = [__v_3, __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_18: usize = 4; -const IN_18: usize = 4; -const OUT_18: usize = 2; -fn aiur_fn_18( - inp: [G; IN_18], +const INPUT_SIZE_19: usize = 4; +const IN_19: usize = 4; +const OUT_19: usize = 2; +fn aiur_fn_19( + inp: [G; IN_19], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_18], 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]; @@ -864,21 +883,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_19] = [__v_8, __v_11]; + 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_19: usize = 2; -const IN_19: usize = 2; -const OUT_19: usize = 2; -fn aiur_fn_19( - inp: [G; IN_19], +const INPUT_SIZE_20: usize = 2; +const IN_20: usize = 2; +const OUT_20: usize = 2; +fn aiur_fn_20( + inp: [G; IN_20], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_19], 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]; @@ -905,21 +924,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_20] = [__v_15, __v_18]; + 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_20: usize = 4; -const IN_20: usize = 4; -const OUT_20: usize = 2; -fn aiur_fn_20( - inp: [G; IN_20], +const INPUT_SIZE_21: usize = 4; +const IN_21: usize = 4; +const OUT_21: usize = 2; +fn aiur_fn_21( + inp: [G; IN_21], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_20], 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]; @@ -956,21 +975,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_21] = [__v_25, __v_28]; + 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_21: usize = 4; -const IN_21: usize = 4; -const OUT_21: usize = 1; -fn aiur_fn_21( - inp: [G; IN_21], +const INPUT_SIZE_22: usize = 4; +const IN_22: usize = 4; +const OUT_22: usize = 1; +fn aiur_fn_22( + inp: [G; IN_22], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_21], ExecError> { +) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -981,21 +1000,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_22] = [__v_8]; + 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_22: usize = 1; -const IN_22: usize = 1; -const OUT_22: usize = 2; -fn aiur_fn_22( - inp: [G; IN_22], +const INPUT_SIZE_23: usize = 1; +const IN_23: usize = 1; +const OUT_23: usize = 2; +fn aiur_fn_23( + inp: [G; IN_23], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_22], ExecError> { +) -> Result<[G; OUT_23], 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 +1023,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_23] = [__v_2, __v_3]; + 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); }, 1u64 => { @@ -1013,8 +1032,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_23] = [__v_4, __v_7]; + 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); }, _ => { @@ -1024,59 +1043,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_24: usize = 1; +const IN_24: usize = 1; +const OUT_24: usize = 9; +fn aiur_fn_24( + inp: [G; IN_24], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_23], ExecError> { +) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_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_23] = { let __args: [G; IN_23] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_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_23] = { let __args: [G; IN_23] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_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_23] = { let __args: [G; IN_23] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_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_23] = { let __args: [G; IN_23] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_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_23] = { let __args: [G; IN_23] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_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_23] = { let __args: [G; IN_23] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_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_23] = { let __args: [G; IN_23] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; let __v_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_24] = [__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[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); }) } -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_25: usize = 1; +const IN_25: usize = 1; +const OUT_25: usize = 2; +fn aiur_fn_25( + inp: [G; IN_25], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_24], 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_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_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 __v_3: G = __r_arr[2]; @@ -1086,23 +1105,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_11] = { let __args: [G; IN_11] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_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_25] = [__v_10, __v_9]; + 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_25: usize = 1; -const IN_25: usize = 1; -const OUT_25: usize = 2; -fn aiur_fn_25( - inp: [G; IN_25], +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_25], ExecError> { +) -> Result<[G; OUT_26], 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 +1129,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_26] = [__v_2, __v_4]; + 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_26: usize = 1; -const IN_26: usize = 1; -const OUT_26: usize = 9; -fn aiur_fn_26( - inp: [G; IN_26], +const INPUT_SIZE_27: usize = 1; +const IN_27: usize = 1; +const OUT_27: usize = 9; +fn aiur_fn_27( + inp: [G; IN_27], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_26], ExecError> { +) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -1139,24 +1158,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_27] = [__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[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_27: usize = 1; -const IN_27: usize = 1; -const OUT_27: usize = 2; -fn aiur_fn_27( - inp: [G; IN_27], +const INPUT_SIZE_28: usize = 1; +const IN_28: usize = 1; +const OUT_28: usize = 2; +fn aiur_fn_28( + inp: [G; IN_28], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_27], ExecError> { +) -> Result<[G; OUT_28], 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_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 __v_3: G = __r_arr[2]; @@ -1166,26 +1185,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_11] = { let __args: [G; IN_11] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_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_28] = [__v_10, __v_9]; + 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_28: usize = 1; -const IN_28: usize = 1; -const OUT_28: usize = 3; -fn aiur_fn_28( - inp: [G; IN_28], +const INPUT_SIZE_29: usize = 1; +const IN_29: usize = 1; +const OUT_29: usize = 3; +fn aiur_fn_29( + inp: [G; IN_29], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_28], ExecError> { +) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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_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 __v_3: G = __r_arr[2]; @@ -1195,7 +1214,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_27] = { let __args: [G; IN_27] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -1247,24 +1266,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_29] = [__v_39, __v_60, __v_18]; + 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_29: usize = 1; -const IN_29: usize = 1; -const OUT_29: usize = 33; -fn aiur_fn_29( - inp: [G; IN_29], +const INPUT_SIZE_30: usize = 1; +const IN_30: usize = 1; +const OUT_30: usize = 33; +fn aiur_fn_30( + inp: [G; IN_30], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_29], ExecError> { +) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __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_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 __v_3: G = __r_arr[2]; @@ -1274,7 +1293,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_27] = { let __args: [G; IN_27] = [__v_9]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -1284,7 +1303,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_27] = { let __args: [G; IN_27] = [__v_18]; 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -1294,7 +1313,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_27] = { let __args: [G; IN_27] = [__v_27]; 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_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -1304,44 +1323,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_30] = [__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[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_30: usize = 1; -const IN_30: usize = 1; -const OUT_30: usize = 2; -fn aiur_fn_30( - inp: [G; IN_30], +const INPUT_SIZE_31: usize = 1; +const IN_31: usize = 1; +const OUT_31: usize = 2; +fn aiur_fn_31( + inp: [G; IN_31], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_30], ExecError> { +) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_32] = { let __args: [G; IN_32] = [__v_2, __v_1]; 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_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_31] = [__v_3, __v_4]; + 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_31: usize = 2; -const IN_31: usize = 2; -const OUT_31: usize = 2; -fn aiur_fn_31( - inp: [G; IN_31], +const INPUT_SIZE_32: usize = 2; +const IN_32: usize = 2; +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_31], ExecError> { +) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1350,61 +1369,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_32] = [__v_4, __v_0]; + 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); }, _ => { - 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_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 __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_32] = { let __args: [G; IN_32] = [__v_3, __v_5]; 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_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_32] = [__v_9, __v_7]; + 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_32: usize = 1; -const IN_32: usize = 1; -const OUT_32: usize = 2; -fn aiur_fn_32( - inp: [G; IN_32], +const INPUT_SIZE_33: usize = 1; +const IN_33: usize = 1; +const OUT_33: usize = 2; +fn aiur_fn_33( + inp: [G; IN_33], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_32], ExecError> { +) -> Result<[G; OUT_33], 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; 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_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_33] = [__v_3, __v_4]; + 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_33: usize = 2; -const IN_33: usize = 2; -const OUT_33: usize = 2; -fn aiur_fn_33( - inp: [G; IN_33], +const INPUT_SIZE_34: usize = 2; +const IN_34: usize = 2; +const OUT_34: usize = 2; +fn aiur_fn_34( + inp: [G; IN_34], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_33], ExecError> { +) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1413,12 +1432,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_34] = [__v_4, __v_0]; + 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); }, _ => { - 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_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 = __r_arr[2]; @@ -1430,51 +1449,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_34] = { let __args: [G; IN_34] = [__v_10, __v_12]; 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_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_34] = [__v_16, __v_14]; + 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_34: usize = 1; -const IN_34: usize = 1; -const OUT_34: usize = 2; -fn aiur_fn_34( - inp: [G; IN_34], +const INPUT_SIZE_35: usize = 1; +const IN_35: usize = 1; +const OUT_35: usize = 2; +fn aiur_fn_35( + inp: [G; IN_35], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_34], ExecError> { +) -> Result<[G; OUT_35], 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_36] = { let __args: [G; IN_36] = [__v_2, __v_1]; 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_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_35] = [__v_3, __v_4]; + 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_35: usize = 2; -const IN_35: usize = 2; -const OUT_35: usize = 2; -fn aiur_fn_35( - inp: [G; IN_35], +const INPUT_SIZE_36: usize = 2; +const IN_36: usize = 2; +const OUT_36: usize = 2; +fn aiur_fn_36( + inp: [G; IN_36], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_35], ExecError> { +) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1483,12 +1502,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_36] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __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_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 = __r_arr[2]; @@ -1498,7 +1517,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_27] = { let __args: [G; IN_27] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -1552,51 +1571,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_36] = { let __args: [G; IN_36] = [__v_19, __v_63]; 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_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_36] = [__v_67, __v_65]; + 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_36: usize = 1; -const IN_36: usize = 1; -const OUT_36: usize = 2; -fn aiur_fn_36( - inp: [G; IN_36], +const INPUT_SIZE_37: usize = 1; +const IN_37: usize = 1; +const OUT_37: usize = 2; +fn aiur_fn_37( + inp: [G; IN_37], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_36], ExecError> { +) -> Result<[G; OUT_37], 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_38] = { let __args: [G; IN_38] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } }; let __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_37] = [__v_3, __v_4]; + 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_37: usize = 2; -const IN_37: usize = 2; -const OUT_37: usize = 2; -fn aiur_fn_37( - inp: [G; IN_37], +const INPUT_SIZE_38: usize = 2; +const IN_38: usize = 2; +const OUT_38: usize = 2; +fn aiur_fn_38( + inp: [G; IN_38], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_37], ExecError> { +) -> Result<[G; OUT_38], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1605,12 +1624,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_38] = [__v_4, __v_0]; + 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); }, _ => { - 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_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 = __r_arr[2]; @@ -1620,7 +1639,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_27] = { let __args: [G; IN_27] = [__v_10]; 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_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -1630,7 +1649,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_27] = { let __args: [G; IN_27] = [__v_19]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -1640,7 +1659,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_27] = { let __args: [G; IN_27] = [__v_28]; 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_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -1652,52 +1671,52 @@ 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_38] = { let __args: [G; IN_38] = [__v_37, __v_39]; 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_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_37] = [__v_44, __v_41]; - if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_38] = [__v_44, __v_41]; + 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_38: usize = 1; -const IN_38: usize = 1; -const OUT_38: usize = 2; -fn aiur_fn_38( - inp: [G; IN_38], +const INPUT_SIZE_39: usize = 1; +const IN_39: usize = 1; +const OUT_39: usize = 2; +fn aiur_fn_39( + inp: [G; IN_39], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_38], ExecError> { +) -> Result<[G; OUT_39], 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_2, __v_1]; 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 __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_38] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_39] = [__v_3, __v_4]; + 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_39: usize = 2; -const IN_39: usize = 2; -const OUT_39: usize = 2; -fn aiur_fn_39( - inp: [G; IN_39], +const INPUT_SIZE_40: usize = 2; +const IN_40: usize = 2; +const OUT_40: usize = 2; +fn aiur_fn_40( + inp: [G; IN_40], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_39], ExecError> { +) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1706,61 +1725,61 @@ fn aiur_fn_39( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_39] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_40] = [__v_4, __v_0]; + 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); }, _ => { - let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__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 __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_39] = [__v_9, __v_7]; - if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_40] = [__v_9, __v_7]; + 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_40: usize = 1; -const IN_40: usize = 1; -const OUT_40: usize = 2; -fn aiur_fn_40( - inp: [G; IN_40], +const INPUT_SIZE_41: usize = 1; +const IN_41: usize = 1; +const OUT_41: usize = 2; +fn aiur_fn_41( + inp: [G; IN_41], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_40], ExecError> { +) -> Result<[G; OUT_41], 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_1]; 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_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_40] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_41] = [__v_3, __v_4]; + 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_41: usize = 2; -const IN_41: usize = 2; -const OUT_41: usize = 2; -fn aiur_fn_41( - inp: [G; IN_41], +const INPUT_SIZE_42: usize = 2; +const IN_42: usize = 2; +const OUT_42: usize = 2; +fn aiur_fn_42( + inp: [G; IN_42], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_41], ExecError> { +) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1769,61 +1788,64 @@ fn aiur_fn_41( 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)); }; + let __ret: [G; OUT_42] = [__v_4, __v_0]; + 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); }, _ => { - 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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)); }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_3, __v_2]; 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 __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_42] = { let __args: [G; IN_42] = [__v_5, __v_7]; 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_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_42] = [__v_11, __v_9]; + 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_42: usize = 1; -const IN_42: usize = 1; -const OUT_42: usize = 2; -fn aiur_fn_42( - inp: [G; IN_42], +const INPUT_SIZE_43: usize = 1; +const IN_43: usize = 1; +const OUT_43: usize = 2; +fn aiur_fn_43( + inp: [G; IN_43], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_42], ExecError> { +) -> Result<[G; OUT_43], 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; 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 __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)); }; + let __ret: [G; OUT_43] = [__v_3, __v_4]; + 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_43: usize = 2; -const IN_43: usize = 2; -const OUT_43: usize = 2; -fn aiur_fn_43( - inp: [G; IN_43], +const INPUT_SIZE_44: usize = 2; +const IN_44: usize = 2; +const OUT_44: usize = 2; +fn aiur_fn_44( + inp: [G; IN_44], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_43], ExecError> { +) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -1832,49 +1854,29 @@ fn aiur_fn_43( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_43] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_44] = [__v_4, __v_0]; + 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); }, _ => { - 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_35] = { let __args: [G; IN_35] = [__v_0]; 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_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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_3, __v_5]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_43] = [__v_9, __v_7]; - if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_44] = [__v_9, __v_7]; + 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_44: usize = 1; -const IN_44: usize = 1; -const OUT_44: usize = 2; -fn aiur_fn_44( - inp: [G; IN_44], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_44], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; - let __v_1: G = __r_arr[0]; - let __v_2: G = __r_arr[1]; - let __ret: [G; OUT_44] = [__v_1, __v_2]; - if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - const INPUT_SIZE_45: usize = 1; const IN_45: usize = 1; const OUT_45: usize = 2; @@ -1886,7 +1888,7 @@ fn aiur_fn_45( ) -> 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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)? } }; @@ -1920,7 +1922,7 @@ fn aiur_fn_46( 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_43] = { let __args: [G; IN_43] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); @@ -1940,7 +1942,7 @@ fn aiur_fn_46( const INPUT_SIZE_47: usize = 1; const IN_47: usize = 1; -const OUT_47: usize = 4; +const OUT_47: usize = 2; fn aiur_fn_47( inp: [G; IN_47], record: &mut QueryRecord, @@ -1949,16 +1951,10 @@ 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_37] = { let __args: [G; IN_37] = [__v_0]; 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_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_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_1, __v_2]; 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); }) @@ -1966,7 +1962,7 @@ fn aiur_fn_47( const INPUT_SIZE_48: usize = 1; const IN_48: usize = 1; -const OUT_48: usize = 3; +const OUT_48: usize = 2; fn aiur_fn_48( inp: [G; IN_48], record: &mut QueryRecord, @@ -1975,23 +1971,20 @@ 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __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]; + let __ret: [G; OUT_48] = [__v_3, __v_4]; 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 INPUT_SIZE_49: usize = 2; +const IN_49: usize = 2; const OUT_49: usize = 2; fn aiur_fn_49( inp: [G; IN_49], @@ -1999,29 +1992,6 @@ fn aiur_fn_49( 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_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_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; - let __v_3: G = __r_arr[0]; - let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_49] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_50: usize = 2; -const IN_50: usize = 2; -const OUT_50: usize = 2; -fn aiur_fn_50( - inp: [G; IN_50], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -2029,39 +1999,59 @@ fn aiur_fn_50( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_50] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_49] = [__v_4, __v_0]; + 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); }, _ => { - 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_37] = { let __args: [G; IN_37] = [__v_0]; 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_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __v_4: G = G::from_u64(1); + let __v_5: G = (__v_1 - __v_4); + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __v_8: G = G::from_u64(1); - let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - let __v_11: G = __r_arr[1]; - let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_50] = [__v_13, __v_11]; - if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_49] = [__v_9, __v_7]; + 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 = 4; +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_37] = { let __args: [G; IN_37] = [__v_0]; 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_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]; 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 __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_4]; 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_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __ret: [G; OUT_50] = [__v_1, __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 = 3; fn aiur_fn_51( inp: [G; IN_51], record: &mut QueryRecord, @@ -2070,16 +2060,16 @@ 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_42] = { let __args: [G; IN_42] = [__v_2, __v_1]; 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_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_37] = { let __args: [G; IN_37] = [__v_4]; 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_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_5, __v_6]; if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) @@ -2096,7 +2086,7 @@ 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 __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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)? } }; @@ -2124,19 +2114,19 @@ fn aiur_fn_53( 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 __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_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)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_42] = { let __args: [G; IN_42] = [__v_3, __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 __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_37] = { let __args: [G; IN_37] = [__v_5]; 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_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); @@ -2145,7 +2135,7 @@ fn aiur_fn_53( 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 __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_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)); }; return Ok(__ret); @@ -2156,7 +2146,7 @@ fn aiur_fn_53( const INPUT_SIZE_54: usize = 1; const IN_54: usize = 1; -const OUT_54: usize = 3; +const OUT_54: usize = 4; fn aiur_fn_54( inp: [G; IN_54], record: &mut QueryRecord, @@ -2165,19 +2155,19 @@ fn aiur_fn_54( ) -> Result<[G; OUT_54], 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_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 __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_28] = { let __args: [G; IN_28] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_44] = { let __args: [G; IN_44] = [__v_4, __v_3]; 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_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_37] = { let __args: [G; IN_37] = [__v_6]; 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_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_54] = [__v_3, __v_7, __v_8]; + let __ret: [G; OUT_54] = [__v_1, __v_5, __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)); }; return Ok(__ret); }) @@ -2194,7 +2184,7 @@ fn aiur_fn_55( ) -> Result<[G; OUT_55], 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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)? } }; @@ -2222,22 +2212,22 @@ fn aiur_fn_56( 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 __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_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)); }; 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_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 __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_28] = { let __args: [G; IN_28] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_44] = { let __args: [G; IN_44] = [__v_5, __v_4]; 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_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_37] = { let __args: [G; IN_37] = [__v_7]; 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_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); @@ -2246,7 +2236,7 @@ fn aiur_fn_56( 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 __v_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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)); }; return Ok(__ret); @@ -2257,7 +2247,7 @@ fn aiur_fn_56( const INPUT_SIZE_57: usize = 1; const IN_57: usize = 1; -const OUT_57: usize = 13; +const OUT_57: usize = 14; fn aiur_fn_57( inp: [G; IN_57], record: &mut QueryRecord, @@ -2266,35 +2256,41 @@ fn aiur_fn_57( ) -> 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_49] = { let __args: [G; IN_49] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __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_33] = { let __args: [G; IN_33] = [__v_4]; 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_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_28] = { let __args: [G; IN_28] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_53] = { let __args: [G; IN_53] = [__v_8, __v_7]; 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 __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_28] = { let __args: [G; IN_28] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_56] = { let __args: [G; IN_56] = [__v_12, __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 __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __v_15: G = __r_arr[2]; - let __v_16: G = __r_arr[3]; - let __v_17: G = __r_arr[4]; - let __v_18: G = __r_arr[5]; - let __v_19: G = __r_arr[6]; - let __v_20: G = __r_arr[7]; - let __v_21: G = __r_arr[8]; - let __ret: [G; OUT_57] = [__v_3, __v_5, __v_9, __v_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_14]; 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_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 = 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_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __v_19: G = __r_arr[2]; + let __v_20: G = __r_arr[3]; + let __v_21: G = __r_arr[4]; + let __v_22: G = __r_arr[5]; + let __v_23: G = __r_arr[6]; + let __v_24: G = __r_arr[7]; + let __v_25: G = __r_arr[8]; + let __ret: [G; OUT_57] = [__v_3, __v_5, __v_9, __v_13, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; if 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); }) @@ -2311,7 +2307,7 @@ fn aiur_fn_58( ) -> Result<[G; OUT_58], 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_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 __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -2323,7 +2319,7 @@ fn aiur_fn_58( 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_45] = { let __args: [G; IN_45] = [__v_2]; 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 __v_5: G = G::from_u64(1); @@ -2337,7 +2333,7 @@ fn aiur_fn_58( const INPUT_SIZE_59: usize = 1; const IN_59: usize = 1; -const OUT_59: usize = 24; +const OUT_59: usize = 25; fn aiur_fn_59( inp: [G; IN_59], record: &mut QueryRecord, @@ -2346,72 +2342,78 @@ fn aiur_fn_59( ) -> 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_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_32] = { let __args: [G; IN_32] = [__v_2, __v_1]; 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_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_37] = { let __args: [G; IN_37] = [__v_4]; 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_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_37] = { let __args: [G; IN_37] = [__v_6]; 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_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_37] = { let __args: [G; IN_37] = [__v_8]; 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_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_35] = { let __args: [G; IN_35] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __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_28] = { let __args: [G; IN_28] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_32] = { let __args: [G; IN_32] = [__v_14, __v_13]; 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_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_28] = { let __args: [G; IN_28] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_49] = { let __args: [G; IN_49] = [__v_18, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __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_33] = { let __args: [G; IN_33] = [__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_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_28] = { let __args: [G; IN_28] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_53] = { let __args: [G; IN_53] = [__v_24, __v_23]; 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 __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_28] = { let __args: [G; IN_28] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_56] = { let __args: [G; IN_56] = [__v_28, __v_27]; 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 __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __v_31: G = __r_arr[2]; - let __v_32: G = __r_arr[3]; - let __v_33: G = __r_arr[4]; - let __v_34: G = __r_arr[5]; - let __v_35: G = __r_arr[6]; - let __v_36: G = __r_arr[7]; - let __v_37: G = __r_arr[8]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_38: G = __r_arr[0]; - let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; - let __v_40: G = __r_arr[0]; - let __v_41: G = __r_arr[1]; - let __v_42: G = __r_arr[2]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_43: G = __r_arr[0]; - let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_45: G = __r_arr[0]; - let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_59] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_40, __v_41, __v_43, __v_45, __v_46]; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_32]; 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_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __v_35: G = __r_arr[2]; + let __v_36: G = __r_arr[3]; + let __v_37: G = __r_arr[4]; + let __v_38: G = __r_arr[5]; + let __v_39: G = __r_arr[6]; + let __v_40: G = __r_arr[7]; + let __v_41: G = __r_arr[8]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_41]; 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_42: G = __r_arr[0]; + let __v_43: G = __r_arr[1]; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43]; 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 __v_46: G = __r_arr[2]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_46]; 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_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_48]; 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_49: G = __r_arr[0]; + let __v_50: 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_29, __v_31, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_42, __v_44, __v_45, __v_47, __v_49, __v_50]; if 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); }) @@ -4394,7 +4396,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_2] = { let __args: [G; IN_2] = [__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[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_17: G = __r_arr[0]; let __v_18: G = (__v_17 * __v_8); let __v_19: G = (__v_2 - __v_1); @@ -4665,7 +4667,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_212] = { let __args: [G; IN_212] = [__v_0]; 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_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 +4678,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_2] = { let __args: [G; IN_2] = [__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[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_82: G = __r_arr[0]; let __v_83: G = (__v_73 * __v_82); let __v_84: G = (__v_8 * __v_83); @@ -4828,7 +4830,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_10] = { let __args: [G; IN_10] = [__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[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 __v_229: G = __r_arr[0]; let __v_230: G = __r_arr[1]; let __v_231: G = __r_arr[2]; @@ -4846,10 +4848,10 @@ fn aiur_fn_69( 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_212] = { let __args: [G; IN_212] = [__v_0]; 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_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_212] = { let __args: [G; IN_212] = [__v_0]; 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_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 +4862,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_2] = { let __args: [G; IN_2] = [__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[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_84: G = __r_arr[0]; let __v_85: G = (__v_84 * __v_8); let __v_86: G = (__v_75 * __v_85); @@ -9156,7 +9158,7 @@ fn aiur_fn_94( 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 __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_87, __v_107]; 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_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)); }; @@ -10240,7 +10242,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_2] = { let __args: [G; IN_2] = [__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[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_129: G = __r_arr[0]; let __v_130: G = (__v_113 * __v_129); let __v_131: G = G::from_u64(2); @@ -10400,7 +10402,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_10] = { let __args: [G; IN_10] = [__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[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 __v_273: G = __r_arr[0]; let __v_274: G = __r_arr[1]; let __v_275: G = __r_arr[2]; @@ -10718,9 +10720,9 @@ fn aiur_fn_107( }) } -const INPUT_SIZE_108: usize = 6; -const IN_108: usize = 6; -const OUT_108: usize = 2; +const INPUT_SIZE_108: usize = 2; +const IN_108: usize = 2; +const OUT_108: usize = 1; fn aiur_fn_108( inp: [G; IN_108], record: &mut QueryRecord, @@ -10730,82 +10732,97 @@ fn aiur_fn_108( stacker::maybe_grow(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() { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; - let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_108] = [__v_0, __v_9]; + let __ret: [G; OUT_108] = [__v_1]; 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); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_9: G = __loaded[0]; - let __v_10: G = __loaded[1]; - let __v_11: G = __loaded[2]; - match __v_9.as_canonical_u64() { - 0u64 => { - let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { - 0u64 => { - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - break '__mc_0 [__v_12]; - }, - _ => { - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_7, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - break '__mc_0 [__v_12]; - }, -} - }; - let __v_12: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; - let __v_13: G = __r_arr[0]; - let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_13.as_canonical_u64() { - 0u64 => { - break '__mc_1 [__v_12]; - }, - _ => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; - let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; - let __v_15: G = __r_arr[0]; - break '__mc_1 [__v_15]; - }, -} - }; - let __v_14: G = __mc_out___mc_1[0]; - let __v_15: G = G::from_u64(1); - let __v_16: G = (__v_5 - __v_15); - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_14, __v_1, __v_2, __v_8, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; - let __v_17: G = __r_arr[0]; - let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_108] = [__v_17, __v_18]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_108] = [__v_0]; 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); }, + 0u64 => { + match __v_3.as_canonical_u64() { + _ => { + match __v_9.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; let __cu = unconstrained; 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_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7, __v_1]; 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_16: G = __r_arr[0]; + let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_17]; + 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); + }, + _ => { + let __v_15: G = (__v_3 - __v_9); + let __v_16: G = G::from_bool((__v_15 == G::ZERO)); + match __v_16.as_canonical_u64() { + 1u64 => { + if (__v_6 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); + } + let __v_17: G = G::from_u64(0); + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7, __v_13]; 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_18: G = __r_arr[0]; + let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_19]; + if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_17: G = G::from_u64(0); + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_13]; 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_18: G = __r_arr[0]; + let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_19]; + if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, _ => { - return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); }, } }) } -const INPUT_SIZE_109: usize = 5; -const IN_109: usize = 5; +const INPUT_SIZE_109: usize = 1; +const IN_109: usize = 1; const OUT_109: usize = 2; fn aiur_fn_109( inp: [G; IN_109], @@ -10815,25 +10832,73 @@ fn aiur_fn_109( ) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __v_6: G = G::from_u64(1); - let __v_7: G = (__v_4 - __v_6); - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_5, __v_0, __v_1, __v_3, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_109] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 6] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_109] = [__v_9, __v_12]; + 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); + }, + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 6] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __values: [G; 6] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_109] = [__v_17, __v_20]; + 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); + }, + 0u64 => { + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 6] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_109] = [__v_16, __v_18]; + 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); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } }) } -const INPUT_SIZE_110: usize = 6; -const IN_110: usize = 6; +const INPUT_SIZE_110: usize = 1; +const IN_110: usize = 1; const OUT_110: usize = 1; fn aiur_fn_110( inp: [G; IN_110], @@ -10843,30 +10908,61 @@ fn aiur_fn_110( ) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = G::from_u64(1); - let __v_8: G = (__v_5 - __v_7); - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_6, __v_1, __v_2, __v_4, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; - let __v_9: G = __r_arr[0]; - let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = (__v_11 - __v_9); - let __v_13: G = G::from_bool((__v_12 == G::ZERO)); - let __ret: [G; OUT_110] = [__v_13]; - if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_110] = [__v_0]; + 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 __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_110] = [__v_0]; + 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 __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_109(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_13]; 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_15: G = __r_arr[0]; + 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_16: G = __r_arr[0]; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_110] = [__v_17]; + 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_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } }) } -const INPUT_SIZE_111: usize = 2; -const IN_111: usize = 2; +const INPUT_SIZE_111: usize = 4; +const IN_111: usize = 4; const OUT_111: usize = 1; fn aiur_fn_111( inp: [G; IN_111], @@ -10877,41 +10973,372 @@ fn aiur_fn_111( stacker::maybe_grow(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_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_2: G = __loaded[0]; - let __v_3: G = __loaded[1]; - let __v_4: G = __loaded[2]; - match __v_2.as_canonical_u64() { + let __v_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_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)); }; - 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_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_7: G = __r_arr[0]; - let __ret: [G; OUT_111] = [__v_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: None }); + } + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __values: [G; 6] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_111] = [__v_11]; 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_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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 __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_8, __v_2, __v_3]; 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_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_111] = [__v_14]; + 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_7.as_canonical_u64())); + }, + } + }, _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_112: usize = 2; -const IN_112: usize = 2; -const OUT_112: usize = 1; +const INPUT_SIZE_112: usize = 4; +const IN_112: usize = 4; +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 __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + let __v_9: G = __loaded[5]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_112] = [__v_12, __v_1]; + 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); + }, + 0u64 => { + match __v_5.as_canonical_u64() { + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_107] = { let __args: [G; IN_107] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = __loaded[3]; + let __v_18: G = __loaded[4]; + let __v_19: G = __loaded[5]; + match __v_14.as_canonical_u64() { + 0u64 => { + match __v_15.as_canonical_u64() { + _ => { + 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_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + match __v_20.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = (__v_13 - __v_23); + let __v_25: G = G::from_bool((__v_24 == G::ZERO)); + match __v_25.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_8, __v_18]; 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_26: G = __r_arr[0]; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_7, __v_2, __v_3, __v_26]; 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_27: G = __r_arr[0]; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = G::from_u64(0); + let __v_31: G = { let __values: [G; 6] = [__v_30, __v_13, __v_12, __v_7, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_112] = [__v_31, __v_29]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_26: G = __loaded[0]; + let __v_27: G = __loaded[1]; + let __v_28: G = __loaded[2]; + match __v_26.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_7, __v_2, __v_3, __v_29]; 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_30: G = __r_arr[0]; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = G::from_u64(0); + let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_112] = [__v_34, __v_32]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + } + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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 __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_7, __v_2, __v_3, __v_23]; 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_24: G = __r_arr[0]; + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(1); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_27, __v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_112] = [__v_29, __v_22]; + if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_113: usize = 4; +const IN_113: usize = 4; +const OUT_113: usize = 2; +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]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_113] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(1); + let __v_5: G = (__v_3 - __v_4); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_3 - __v_8); + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_6, __v_7, __v_2, __v_9]; 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_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_113] = [__v_10, __v_11]; + 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 = 6; +const IN_114: usize = 6; +const OUT_114: usize = 1; +fn aiur_fn_114( + inp: [G; IN_114], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_114], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = 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_111] = { let __args: [G; IN_111] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_6]; 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_7: G = __r_arr[0]; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7, __v_4, __v_2, __v_5]; 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_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + let __v_14: G = __loaded[4]; + let __v_15: G = __loaded[5]; + match __v_10.as_canonical_u64() { + 0u64 => { + match __v_11.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_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_16: G = __r_arr[0]; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__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 __v_17: G = __r_arr[0]; + let __v_18: G = (__v_16 - __v_17); + let __v_19: G = G::from_bool((__v_18 == G::ZERO)); + let __v_20: G = G::from_u64(1); + if (__v_19 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_9]; 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_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + if (__v_21 != __v_22) { + return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_15]; 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_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(0); + if (__v_23 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_11]; 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_25: G = __r_arr[0]; + let __v_26: G = (__v_25 - __v_14); + let __v_27: G = G::from_bool((__v_26 == G::ZERO)); + let __ret: [G; OUT_114] = [__v_27]; + 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_10.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_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_115] = [__v_1]; + 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 = 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_115] = { let __args: [G; IN_115] = [__v_4, __v_6]; 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_7: G = __r_arr[0]; + 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 = 2; +const IN_116: usize = 2; +const OUT_116: usize = 1; +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]; @@ -10922,24 +11349,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_116] = [__v_5]; + if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __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_116] = { let __args: [G; IN_116] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; 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_116] = [__v_6]; + 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); }, _ => { 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_116] = [__v_7]; + 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); }, } @@ -10951,15 +11378,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_117: usize = 8; +const IN_117: usize = 8; +const OUT_117: usize = 2; +fn aiur_fn_117( + inp: [G; IN_117], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_113], 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]; @@ -10971,14 +11398,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_174] = { let __args: [G; IN_174] = [__v_9]; 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_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_115] = { let __args: [G; IN_115] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__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_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_116] = { let __args: [G; IN_116] = [__v_10, __v_14]; 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_15: G = __r_arr[0]; let __v_16: G = (__v_15 + __v_15); let __v_17: G = (__v_4 + __v_6); @@ -11060,50 +11487,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_117] = [__v_82, __v_83]; + 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_114: usize = 2; -const IN_114: usize = 2; -const OUT_114: usize = 1; -fn aiur_fn_114( - inp: [G; IN_114], +const INPUT_SIZE_118: usize = 2; +const IN_118: usize = 2; +const OUT_118: usize = 1; +fn aiur_fn_118( + inp: [G; IN_118], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_114], 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]; 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_174] = { let __args: [G; IN_174] = [__v_1]; 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_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_115] = { let __args: [G; IN_115] = [__v_0, __v_6]; 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_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_116] = { let __args: [G; IN_116] = [__v_3, __v_7]; 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_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_118] = [__v_9]; + 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); }) } -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_119: usize = 8; +const IN_119: usize = 8; +const OUT_119: usize = 4; +fn aiur_fn_119( + inp: [G; IN_119], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_115], 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]; @@ -11126,8 +11553,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_119] = [__v_4, __v_5, __v_6, __v_7]; + if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -11180,13 +11607,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_119] = { let __args: [G; IN_119] = [__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[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_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_119] = [__v_64, __v_65, __v_66, __v_67]; + 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); }, _ => { @@ -11201,15 +11628,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_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_116], 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]; @@ -11220,8 +11647,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_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 => { @@ -11337,14 +11764,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_120] = { let __args: [G; IN_120] = [__v_5, __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_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_158] = { let __args: [G; IN_158] = [__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[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_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_158] = { let __args: [G; IN_158] = [__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[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_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_120] = [__v_98]; + 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); }, _ => { @@ -11354,15 +11781,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_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_117], 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]; @@ -11372,17 +11799,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_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_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_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_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_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_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_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); }, _ => { @@ -11392,15 +11819,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_122: usize = 2; +const IN_122: usize = 2; +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_118], 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]; @@ -11410,17 +11837,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_122] = [__v_1]; + if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; 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_122] = { let __args: [G; IN_122] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __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_121] = { let __args: [G; IN_121] = [__v_3, __v_5]; 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_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_122] = [__v_6]; + 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); }, _ => { @@ -11430,30 +11857,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_123: usize = 3; +const IN_123: usize = 3; +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_119], ExecError> { +) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = 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_123] = [__v_2]; + 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); }, 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_122] = { let __args: [G; IN_122] = [__v_1, __v_2]; 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_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_123] = [__v_3]; + 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); }, _ => { @@ -11463,15 +11890,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_124: usize = 2; +const IN_124: usize = 2; +const OUT_124: usize = 1; +fn aiur_fn_124( + inp: [G; IN_124], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_120], 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]; @@ -11481,8 +11908,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_124] = [__v_0]; + 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); }, 0u64 => { @@ -11494,12 +11921,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_167] = { let __args: [G; IN_167] = [__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[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_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_124] = { let __args: [G; IN_124] = [__v_13, __v_4]; 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_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_124] = [__v_14]; + if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11509,15 +11936,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_125: usize = 10; +const IN_125: usize = 10; +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_121], 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]; @@ -11534,17 +11961,17 @@ 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_125] = [__v_0, __v_12]; + if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __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_167] = { let __args: [G; IN_167] = [__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[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_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_166] = { let __args: [G; IN_166] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -11554,23 +11981,23 @@ fn aiur_fn_121( 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_125] = [__v_15, __v_16]; + 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); }, } }) } -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_126: usize = 4; +const IN_126: usize = 4; +const OUT_126: usize = 2; +fn aiur_fn_126( + inp: [G; IN_126], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_122], 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]; @@ -11585,8 +12012,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_126] = [__v_9, __v_0]; + 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); }, 0u64 => { @@ -11603,12 +12030,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_168] = { let __args: [G; IN_168] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_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_125] = { let __args: [G; IN_125] = [__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[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __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_164] = { let __args: [G; IN_164] = [__v_18, __v_19]; 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_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -11627,7 +12054,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_126] = { let __args: [G; IN_126] = [__v_36, __v_6, __v_16, __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_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(0); @@ -11674,8 +12101,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_126] = [__v_83, __v_39]; + 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); }, _ => { @@ -11690,15 +12117,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_127: usize = 5; +const IN_127: usize = 5; +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_123], 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]; @@ -11708,12 +12135,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_127] = [__v_5]; + 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 __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_204] = { let __args: [G; IN_204] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__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_5: G = __r_arr[0]; let __v_6: G = (__v_1 - __v_4); let __v_7: G = (__v_5 + __v_6); @@ -11721,8 +12148,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_127] = [__v_9]; + 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); }, _ => { @@ -11730,10 +12157,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_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_10, __v_12, __v_4]; 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 __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_127] = [__v_13]; + 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); }, } @@ -11742,15 +12169,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_128: usize = 4; +const IN_128: usize = 4; +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_124], 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]; @@ -11761,22 +12188,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_128] = [__v_6]; + 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_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_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_4, __v_3]; 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_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_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __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_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_128] = [__v_8]; + 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); }, _ => { @@ -11787,11 +12214,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_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_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_128] = [__v_14]; + if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -11800,15 +12227,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_129: usize = 8; +const IN_129: usize = 8; +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_125], 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]; @@ -11831,8 +12258,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_129] = [__v_17]; + 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 => { @@ -11844,7 +12271,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_119] = { let __args: [G; IN_119] = [__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[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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -11861,17 +12288,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_129] = [__v_34]; + 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 __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_129] = { let __args: [G; IN_129] = [__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[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_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_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); }, } @@ -11885,15 +12312,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_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_126], 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]; @@ -11908,8 +12335,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_130] = [__v_9]; + 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); }, 0u64 => { @@ -11931,15 +12358,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_130] = [__v_19]; + 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); }, _ => { - 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_130] = { let __args: [G; IN_130] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_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_130] = [__v_11]; + 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); }, } @@ -11953,29 +12380,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_131: usize = 2; +const IN_131: usize = 2; +const OUT_131: usize = 1; +fn aiur_fn_131( + inp: [G; IN_131], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_127], 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]; 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_131] = [__v_2]; + if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 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_131] = [__v_2]; + if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -11985,15 +12412,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_132: usize = 10; +const IN_132: usize = 10; +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_128], 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]; @@ -12006,17 +12433,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_216] = { let __args: [G; IN_216] = [__v_2, __v_10]; 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_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_174] = { let __args: [G; IN_174] = [__v_1]; 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_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_115] = { let __args: [G; IN_115] = [__v_11, __v_16]; 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_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_116] = { let __args: [G; IN_116] = [__v_13, __v_17]; 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_18: G = __r_arr[0]; let __v_19: G = (__v_12 * __v_18); let __v_20: G = G::from_u64(0); @@ -12045,9 +12472,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_210] = { let __args: [G; IN_210] = [__v_6]; 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 __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_206] = { let __args: [G; IN_206] = [__v_7]; 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_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 +12482,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_129] = { let __args: [G; IN_129] = [__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[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_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_132] = [__v_45]; + 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_129: usize = 11; -const IN_129: usize = 11; -const OUT_129: usize = 1; -fn aiur_fn_129( - inp: [G; IN_129], +const INPUT_SIZE_133: usize = 11; +const IN_133: usize = 11; +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_129], 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]; @@ -12085,12 +12512,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_204] = { let __args: [G; IN_204] = [__v_8, __v_11]; 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_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_204] = { let __args: [G; IN_204] = [__v_8, __v_13]; 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_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_174] = { let __args: [G; IN_174] = [__v_4]; 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_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); let __v_17: G = (__v_5 * __v_15); @@ -12101,25 +12528,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_132] = { let __args: [G; IN_132] = [__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[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_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_132] = { let __args: [G; IN_132] = [__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[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_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_133] = [__v_26]; + 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_130: usize = 13; -const IN_130: usize = 13; -const OUT_130: usize = 1; -fn aiur_fn_130( - inp: [G; IN_130], +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_130], 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]; @@ -12136,43 +12563,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_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_204] = { let __args: [G; IN_204] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_133] = { let __args: [G; IN_133] = [__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[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_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_134] = { let __args: [G; IN_134] = [__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[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_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_134] = [__v_22]; + 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_131: usize = 13; -const IN_131: usize = 13; -const OUT_131: usize = 1; -fn aiur_fn_131( - inp: [G; IN_131], +const INPUT_SIZE_135: usize = 13; +const IN_135: usize = 13; +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_131], 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]; @@ -12189,46 +12616,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_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_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_204] = { let __args: [G; IN_204] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_16, __v_17]; 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_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_132] = { let __args: [G; IN_132] = [__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[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_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_135] = { let __args: [G; IN_135] = [__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[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_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_135] = [__v_24]; + 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); }, } }) } -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_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_132], 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]; @@ -12247,12 +12674,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_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); }, _ => { - 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_213] = { let __args: [G; IN_213] = [__v_8, __v_4]; 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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -12261,21 +12688,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_136] = { let __args: [G; IN_136] = [__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[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_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_136] = [__v_21]; + 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 __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_204] = { let __args: [G; IN_204] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_11, __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_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_204] = { let __args: [G; IN_204] = [__v_12, __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_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_133] = { let __args: [G; IN_133] = [__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[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_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_4 + __v_22); @@ -12283,10 +12710,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_136] = { let __args: [G; IN_136] = [__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[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_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_136] = [__v_28]; + 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); }, _ => { @@ -12298,15 +12725,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_137: usize = 15; +const IN_137: usize = 15; +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_133], 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]; @@ -12325,47 +12752,37 @@ 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_137] = [__v_0]; + 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); }, 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_204] = { let __args: [G; IN_204] = [__v_1, __v_15]; 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_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 __v_17: G = G::from_u64(0); + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_6, __v_10, __v_5, __v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__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_205] = { let __args: [G; IN_205] = [__v_16]; 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_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_205] = { let __args: [G; IN_205] = [__v_4]; 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_21: G = __r_arr[0]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_22: G = __r_arr[0]; - let __v_23: G = (__v_21 - __v_22); - let __v_24: G = G::from_bool((__v_23 == G::ZERO)); - let __v_25: G = G::from_u64(1); - if (__v_24 != __v_25) { - return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None }); + let __v_22: G = (__v_20 - __v_21); + let __v_23: G = G::from_bool((__v_22 == G::ZERO)); + let __v_24: G = G::from_u64(1); + if (__v_23 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __v_26: G = (__v_9 - __v_20); - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_8, __v_9, __v_10, __v_25, __v_7, __v_26, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; 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_27: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_2, __v_16, __v_19, __v_27, __v_17, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; - let __v_28: G = __r_arr[0]; - let __v_29: G = G::from_u64(1); - if (__v_28 != __v_29) { - return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None }); - } - let __v_30: G = G::from_u64(0); - let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_8, __v_9, __v_10, __v_30, __v_7, __v_31, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; - let __v_32: G = __r_arr[0]; - let __ret: [G; OUT_133] = [__v_32]; - if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_137] = [__v_27]; + 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); }, } @@ -12377,15 +12794,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_138: usize = 4; +const IN_138: usize = 4; +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_134], ExecError> { +) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12396,39 +12813,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_138] = [__v_6]; + 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 __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_204] = { let __args: [G; IN_204] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__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_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_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_8, __v_10]; 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_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_138] = [__v_12]; + 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); }, } }) } -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_139: usize = 1; +const IN_139: usize = 1; +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_135], ExecError> { +) -> Result<[G; OUT_139], 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 +12855,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_139] = [__v_4]; + if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - 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_139] = { let __args: [G; IN_139] = [__v_3]; 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_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_139] = [__v_4]; + if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_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_139] = [__v_2]; + 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); }, } @@ -12466,15 +12883,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_140: usize = 5; +const IN_140: usize = 5; +const OUT_140: usize = 1; +fn aiur_fn_140( + inp: [G; IN_140], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_136], 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]; @@ -12486,12 +12903,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_140] = [__v_7]; + 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 __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_213] = { let __args: [G; IN_213] = [__v_2, __v_4]; 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_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -12500,26 +12917,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_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_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_140] = [__v_11]; + 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); }, 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_204] = { let __args: [G; IN_204] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_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_140] = [__v_15]; + 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); }, _ => { @@ -12531,15 +12948,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_141: usize = 5; +const IN_141: usize = 5; +const OUT_141: usize = 4; +fn aiur_fn_141( + inp: [G; IN_141], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_137], 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]; @@ -12548,28 +12965,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_141] = [__v_1, __v_2, __v_3, __v_4]; + 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); }, _ => { - 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_141] = [__v_3, __v_4, __v_1, __v_2]; + 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_138: usize = 4; -const IN_138: usize = 4; -const OUT_138: usize = 1; -fn aiur_fn_138( - inp: [G; IN_138], +const INPUT_SIZE_142: usize = 4; +const IN_142: usize = 4; +const OUT_142: usize = 1; +fn aiur_fn_142( + inp: [G; IN_142], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_138], 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]; @@ -12810,21 +13227,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_142] = [__v_194]; + 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); }) } -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_143: usize = 6; +const IN_143: usize = 6; +const OUT_143: usize = 3; +fn aiur_fn_143( + inp: [G; IN_143], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_139], 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]; @@ -12842,8 +13259,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_143] = [__v_0, __v_1, __v_5]; + 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 => { @@ -12854,7 +13271,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_173] = { let __args: [G; IN_173] = [__v_3, __v_4, __v_15]; 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_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = (__v_16 * __v_10); @@ -12867,13 +13284,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_143] = [__v_26, __v_27, __v_12]; + 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); }, _ => { - 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_143] = [__v_0, __v_1, __v_5]; + 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); }, } @@ -12887,15 +13304,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_144: usize = 9; +const IN_144: usize = 9; +const OUT_144: usize = 3; +fn aiur_fn_144( + inp: [G; IN_144], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_140], 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]; @@ -12906,356 +13323,345 @@ fn aiur_fn_140( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __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_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 __v_13: G = (__v_6 - __v_8); + let __v_14: G = G::from_bool((__v_13 == G::ZERO)); + let __v_15: G = G::from_u64(1); + if (__v_14 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; - let __v_17: G = __r_arr[0]; - let __v_18: G = G::from_u64(0); - if (__v_17 != __v_18) { - return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__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 __v_16: G = __r_arr[0]; + let __v_17: G = G::from_u64(0); + if (__v_16 != __v_17) { + return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None }); } - let __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 __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_144] = [__v_0, __v_1, __v_20]; + 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); }, 0u64 => { let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; - let __v_14: G = __loaded[0]; - let __v_15: G = __loaded[1]; - let __v_16: G = __loaded[2]; - let __v_17: G = __loaded[3]; - match __v_14.as_canonical_u64() { + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + match __v_13.as_canonical_u64() { 0u64 => { let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_18: G = __loaded[0]; - let __v_19: G = __loaded[1]; - let __v_20: G = __loaded[2]; - match __v_18.as_canonical_u64() { + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + match __v_17.as_canonical_u64() { 0u64 => { match __v_10.as_canonical_u64() { _ => { let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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() { + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + match __v_20.as_canonical_u64() { 0u64 => { - let __v_24: G = G::from_u64(1); - let __v_25: G = (__v_6 - __v_24); - let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_11, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; - let __v_27: G = __r_arr[0]; - let __v_28: G = __r_arr[1]; - let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_22.as_canonical_u64() { + let __v_23: G = G::from_u64(1); + let __v_24: G = (__v_6 - __v_23); + let __v_25: G = G::from_u64(0); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_11, __v_25]; 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_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_21.as_canonical_u64() { 0u64 => { - break '__mc_0 [__v_0, __v_1, __v_27, __v_28]; + break '__mc_0 [__v_0, __v_1, __v_26, __v_27]; }, _ => { - break '__mc_0 [__v_27, __v_28, __v_0, __v_1]; + break '__mc_0 [__v_26, __v_27, __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 __v_28: G = __mc_out___mc_0[0]; + let __v_29: G = __mc_out___mc_0[1]; + let __v_30: G = __mc_out___mc_0[2]; + let __v_31: G = __mc_out___mc_0[3]; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_22, __v_24, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_32, __v_33, __v_24, __v_14, __v_15, __v_7]; 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_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_34, __v_35, __v_16, __v_19, __v_12, __v_22, __v_24, __v_36, __v_8]; 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_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __gb: [u8; 8] = __v_28.as_canonical_u64().to_le_bytes(); + let __v_40: G = G::from_u8(__gb[0]); + let __v_41: G = G::from_u8(__gb[1]); + let __v_42: G = G::from_u8(__gb[2]); + let __v_43: G = G::from_u8(__gb[3]); + let __v_44: G = G::from_u8(__gb[4]); + let __v_45: G = G::from_u8(__gb[5]); + let __v_46: G = G::from_u8(__gb[6]); + let __v_47: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_48: G = G::from_u64(1020); + let __v_49: G = (__v_47 - __v_48); + let __v_50: G = (__v_46 + __v_49); + let __v_51: G = (__v_45 + __v_50); + let __v_52: G = (__v_44 + __v_51); + let __v_53: G = G::from_bool((__v_52 == G::ZERO)); + let __v_54: G = (__v_42 + __v_43); + let __v_55: G = (__v_41 + __v_54); + let __v_56: G = (__v_40 + __v_55); + let __v_57: G = G::from_bool((__v_56 == G::ZERO)); let __gb: [u8; 8] = __v_29.as_canonical_u64().to_le_bytes(); - let __v_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_58: G = G::from_u8(__gb[0]); + let __v_59: G = G::from_u8(__gb[1]); + let __v_60: G = G::from_u8(__gb[2]); + let __v_61: G = G::from_u8(__gb[3]); + let __v_62: G = G::from_u8(__gb[4]); + let __v_63: G = G::from_u8(__gb[5]); + let __v_64: G = G::from_u8(__gb[6]); + let __v_65: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_66: G = G::from_u64(1020); + let __v_67: G = (__v_65 - __v_66); + let __v_68: G = (__v_64 + __v_67); + let __v_69: G = (__v_63 + __v_68); + let __v_70: G = (__v_62 + __v_69); + let __v_71: G = G::from_bool((__v_70 == G::ZERO)); + let __v_72: G = (__v_60 + __v_61); + let __v_73: G = (__v_59 + __v_72); + let __v_74: G = (__v_58 + __v_73); + let __v_75: G = G::from_bool((__v_74 == G::ZERO)); let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes(); - let __v_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 __v_76: G = G::from_u8(__gb[0]); + let __v_77: G = G::from_u8(__gb[1]); + let __v_78: G = G::from_u8(__gb[2]); + let __v_79: G = G::from_u8(__gb[3]); + let __v_80: G = G::from_u8(__gb[4]); + let __v_81: G = G::from_u8(__gb[5]); + let __v_82: G = G::from_u8(__gb[6]); + let __v_83: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_76; let __vj = __v_77; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_78; let __vj = __v_79; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_80; let __vj = __v_81; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_82; let __vj = __v_83; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_84: G = G::from_u64(1020); + let __v_85: G = (__v_83 - __v_84); + let __v_86: G = (__v_82 + __v_85); + let __v_87: G = (__v_81 + __v_86); + let __v_88: G = (__v_80 + __v_87); + let __v_89: G = G::from_bool((__v_88 == G::ZERO)); + let __v_90: G = (__v_78 + __v_79); + let __v_91: G = (__v_77 + __v_90); + let __v_92: G = (__v_76 + __v_91); + let __v_93: G = G::from_bool((__v_92 == G::ZERO)); let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes(); - let __v_69: G = G::from_u8(__gb[0]); - let __v_70: G = G::from_u8(__gb[1]); - let __v_71: G = G::from_u8(__gb[2]); - let __v_72: G = G::from_u8(__gb[3]); - let __v_73: G = G::from_u8(__gb[4]); - let __v_74: G = G::from_u8(__gb[5]); - let __v_75: G = G::from_u8(__gb[6]); - let __v_76: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_69; let __vj = __v_70; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_71; let __vj = __v_72; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_73; let __vj = __v_74; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_75; let __vj = __v_76; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - let __v_77: G = G::from_u64(1020); - let __v_78: G = (__v_76 - __v_77); - let __v_79: G = (__v_75 + __v_78); - let __v_80: G = (__v_74 + __v_79); - let __v_81: G = (__v_73 + __v_80); - let __v_82: G = G::from_bool((__v_81 == G::ZERO)); - let __v_83: G = (__v_71 + __v_72); - let __v_84: G = (__v_70 + __v_83); - let __v_85: G = (__v_69 + __v_84); - let __v_86: G = G::from_bool((__v_85 == G::ZERO)); - let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes(); - let __v_87: G = G::from_u8(__gb[0]); - let __v_88: G = G::from_u8(__gb[1]); - let __v_89: G = G::from_u8(__gb[2]); - let __v_90: G = G::from_u8(__gb[3]); - let __v_91: G = G::from_u8(__gb[4]); - let __v_92: G = G::from_u8(__gb[5]); - let __v_93: G = G::from_u8(__gb[6]); - let __v_94: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_87; let __vj = __v_88; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_89; let __vj = __v_90; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_91; let __vj = __v_92; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_93; let __vj = __v_94; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - let __v_95: G = G::from_u64(1020); - let __v_96: G = (__v_94 - __v_95); - let __v_97: G = (__v_93 + __v_96); - let __v_98: G = (__v_92 + __v_97); - let __v_99: G = (__v_91 + __v_98); - let __v_100: G = G::from_bool((__v_99 == G::ZERO)); - let __v_101: G = (__v_89 + __v_90); - let __v_102: G = (__v_88 + __v_101); - let __v_103: G = (__v_87 + __v_102); - let __v_104: G = G::from_bool((__v_103 == G::ZERO)); - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_23, __v_25, __v_15, __v_16, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; - let __v_105: G = __r_arr[0]; - let __v_106: G = __r_arr[1]; - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_105, __v_106, __v_25, __v_15, __v_16, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; - let __v_107: G = __r_arr[0]; - let __v_108: G = __r_arr[1]; - let __v_109: G = __r_arr[2]; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; - let __v_110: G = __r_arr[0]; - let __v_111: G = G::from_u64(1); - if (__v_110 != __v_111) { - return Err(ExecError::AssertEqMismatch { lhs: __v_110.as_canonical_u64(), rhs: __v_111.as_canonical_u64(), msg: None }); + let __v_94: G = G::from_u8(__gb[0]); + let __v_95: G = G::from_u8(__gb[1]); + let __v_96: G = G::from_u8(__gb[2]); + let __v_97: G = G::from_u8(__gb[3]); + let __v_98: G = G::from_u8(__gb[4]); + let __v_99: G = G::from_u8(__gb[5]); + let __v_100: G = G::from_u8(__gb[6]); + let __v_101: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_94; let __vj = __v_95; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_96; let __vj = __v_97; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_98; let __vj = __v_99; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_100; let __vj = __v_101; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_102: G = G::from_u64(1020); + let __v_103: G = (__v_101 - __v_102); + let __v_104: G = (__v_100 + __v_103); + let __v_105: G = (__v_99 + __v_104); + let __v_106: G = (__v_98 + __v_105); + let __v_107: G = G::from_bool((__v_106 == G::ZERO)); + let __v_108: G = (__v_96 + __v_97); + let __v_109: G = (__v_95 + __v_108); + let __v_110: G = (__v_94 + __v_109); + let __v_111: G = G::from_bool((__v_110 == G::ZERO)); + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_11]; 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_112: G = __r_arr[0]; + let __v_113: G = G::from_u64(1); + if (__v_112 != __v_113) { + return Err(ExecError::AssertEqMismatch { lhs: __v_112.as_canonical_u64(), rhs: __v_113.as_canonical_u64(), msg: None }); } - let __v_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_114: G = G::from_u64(0); + let __v_115: G = G::from_u64(0); + let __v_116: G = G::from_u64(256); + let __v_117: G = (__v_116 * __v_41); + let __v_118: G = G::from_u64(65536); + let __v_119: G = (__v_118 * __v_42); + let __v_120: G = G::from_u64(16777216); + let __v_121: G = (__v_120 * __v_43); + let __v_122: G = G::from_u64(4294967296); + let __v_123: G = (__v_122 * __v_44); + let __v_124: G = G::from_u64(1099511627776); + let __v_125: G = (__v_124 * __v_45); + let __v_126: G = G::from_u64(281474976710656); + let __v_127: G = (__v_126 * __v_46); + let __v_128: G = G::from_u64(72057594037927936); + let __v_129: G = (__v_128 * __v_47); + let __v_130: G = (__v_127 + __v_129); + let __v_131: G = (__v_125 + __v_130); + let __v_132: G = (__v_123 + __v_131); + let __v_133: G = (__v_121 + __v_132); + let __v_134: G = (__v_119 + __v_133); + let __v_135: G = (__v_117 + __v_134); + let __v_136: G = (__v_40 + __v_135); + if (__v_136 != __v_28) { + return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); } - let __v_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_137: G = G::from_u64(1); + let __v_138: G = G::from_u64(1); + let __v_139: G = (__v_138 - __v_57); + let __v_140: G = (__v_53 * __v_139); + let __v_141: G = (__v_137 - __v_140); + let __v_142: G = G::from_u64(1); + if (__v_141 != __v_142) { + return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_142.as_canonical_u64(), msg: None }); } - let __v_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_143: G = G::from_u64(0); + let __v_144: G = G::from_u64(256); + let __v_145: G = (__v_144 * __v_59); + let __v_146: G = G::from_u64(65536); + let __v_147: G = (__v_146 * __v_60); + let __v_148: G = G::from_u64(16777216); + let __v_149: G = (__v_148 * __v_61); + let __v_150: G = G::from_u64(4294967296); + let __v_151: G = (__v_150 * __v_62); + let __v_152: G = G::from_u64(1099511627776); + let __v_153: G = (__v_152 * __v_63); + let __v_154: G = G::from_u64(281474976710656); + let __v_155: G = (__v_154 * __v_64); + let __v_156: G = G::from_u64(72057594037927936); + let __v_157: G = (__v_156 * __v_65); + let __v_158: G = (__v_155 + __v_157); + let __v_159: G = (__v_153 + __v_158); + let __v_160: G = (__v_151 + __v_159); + let __v_161: G = (__v_149 + __v_160); + let __v_162: G = (__v_147 + __v_161); + let __v_163: G = (__v_145 + __v_162); + let __v_164: G = (__v_58 + __v_163); + if (__v_164 != __v_29) { + return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None }); } - let __v_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_165: G = G::from_u64(1); + let __v_166: G = G::from_u64(1); + let __v_167: G = (__v_166 - __v_75); + let __v_168: G = (__v_71 * __v_167); + let __v_169: G = (__v_165 - __v_168); + let __v_170: G = G::from_u64(1); + if (__v_169 != __v_170) { + return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_170.as_canonical_u64(), msg: None }); } - let __v_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_171: G = G::from_u64(0); + let __v_172: G = G::from_u64(256); + let __v_173: G = (__v_172 * __v_77); + let __v_174: G = G::from_u64(65536); + let __v_175: G = (__v_174 * __v_78); + let __v_176: G = G::from_u64(16777216); + let __v_177: G = (__v_176 * __v_79); + let __v_178: G = G::from_u64(4294967296); + let __v_179: G = (__v_178 * __v_80); + let __v_180: G = G::from_u64(1099511627776); + let __v_181: G = (__v_180 * __v_81); + let __v_182: G = G::from_u64(281474976710656); + let __v_183: G = (__v_182 * __v_82); + let __v_184: G = G::from_u64(72057594037927936); + let __v_185: G = (__v_184 * __v_83); + let __v_186: G = (__v_183 + __v_185); + let __v_187: G = (__v_181 + __v_186); + let __v_188: G = (__v_179 + __v_187); + let __v_189: G = (__v_177 + __v_188); + let __v_190: G = (__v_175 + __v_189); + let __v_191: G = (__v_173 + __v_190); + let __v_192: G = (__v_76 + __v_191); + if (__v_192 != __v_30) { + return Err(ExecError::AssertEqMismatch { lhs: __v_192.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None }); } - let __v_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_193: G = G::from_u64(1); + let __v_194: G = G::from_u64(1); + let __v_195: G = (__v_194 - __v_93); + let __v_196: G = (__v_89 * __v_195); + let __v_197: G = (__v_193 - __v_196); + let __v_198: G = G::from_u64(1); + if (__v_197 != __v_198) { + return Err(ExecError::AssertEqMismatch { lhs: __v_197.as_canonical_u64(), rhs: __v_198.as_canonical_u64(), msg: None }); } - let __v_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_199: G = G::from_u64(0); + let __v_200: G = G::from_u64(256); + let __v_201: G = (__v_200 * __v_95); + let __v_202: G = G::from_u64(65536); + let __v_203: G = (__v_202 * __v_96); + let __v_204: G = G::from_u64(16777216); + let __v_205: G = (__v_204 * __v_97); + let __v_206: G = G::from_u64(4294967296); + let __v_207: G = (__v_206 * __v_98); + let __v_208: G = G::from_u64(1099511627776); + let __v_209: G = (__v_208 * __v_99); + let __v_210: G = G::from_u64(281474976710656); + let __v_211: G = (__v_210 * __v_100); + let __v_212: G = G::from_u64(72057594037927936); + let __v_213: G = (__v_212 * __v_101); + let __v_214: G = (__v_211 + __v_213); + let __v_215: G = (__v_209 + __v_214); + let __v_216: G = (__v_207 + __v_215); + let __v_217: G = (__v_205 + __v_216); + let __v_218: G = (__v_203 + __v_217); + let __v_219: G = (__v_201 + __v_218); + let __v_220: G = (__v_94 + __v_219); + if (__v_220 != __v_31) { + return Err(ExecError::AssertEqMismatch { lhs: __v_220.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); } - let __v_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_221: G = G::from_u64(1); + let __v_222: G = G::from_u64(1); + let __v_223: G = (__v_222 - __v_111); + let __v_224: G = (__v_107 * __v_223); + let __v_225: G = (__v_221 - __v_224); let __v_226: G = G::from_u64(1); - let __v_227: G = { let __values: [G; 10] = [__v_225, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_228: G = { let __values: [G; 10] = [__v_197, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_227]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_229: G = { let __values: [G; 10] = [__v_169, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_230: G = { let __values: [G; 10] = [__v_141, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_231: G = { let __values: [G; 10] = [__v_113, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_232: G = G::from_u64(1); - let __v_233: G = G::from_u64(1); - let __v_234: G = { let __values: [G; 3] = [__v_232, __v_233, __v_233]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_235: G = { let __values: [G; 3] = [__v_112, __v_231, __v_234]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_236: G = G::from_u64(0); - let __v_237: G = G::from_u64(1); - let __v_238: G = G::from_u64(1); - let __v_239: G = { let __values: [G; 3] = [__v_237, __v_238, __v_238]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_240: G = { let __values: [G; 3] = [__v_236, __v_25, __v_239]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_19, __v_235, __v_240, __v_23, __v_12, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; - let __v_241: G = __r_arr[0]; - let __v_242: G = G::from_u64(1); - if (__v_241 != __v_242) { - return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: None }); + if (__v_225 != __v_226) { + return Err(ExecError::AssertEqMismatch { lhs: __v_225.as_canonical_u64(), rhs: __v_226.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_107, __v_108, __v_17, __v_20, __v_13, __v_23, __v_25, __v_109, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; - let __v_243: G = __r_arr[0]; - let __v_244: G = __r_arr[1]; - let __ret: [G; OUT_140] = [__v_243, __v_244]; - if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_227: G = G::from_u64(1); + let __v_228: G = G::from_u64(1); + let __v_229: G = { let __values: [G; 10] = [__v_227, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_199, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_171, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = { let __values: [G; 10] = [__v_143, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_231]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_233: G = { let __values: [G; 10] = [__v_115, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_232]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = { let __values: [G; 3] = [__v_114, __v_233, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_144] = [__v_37, __v_38, __v_234]; + 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_21.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); }, } }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_18.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_13.as_canonical_u64())); }, } }, @@ -13266,15 +13672,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_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_141], 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]; @@ -13303,96 +13709,96 @@ 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_128] = { let __args: [G; IN_128] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __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_138] = { let __args: [G; IN_138] = [__v_15, __v_19, __v_18, __v_26]; 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_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_204] = { let __args: [G; IN_204] = [__v_1, __v_28]; 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_29: G = __r_arr[0]; - let __v_30: G = __r_arr[1]; match __v_29.as_canonical_u64() { _ => { - let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_25, __v_0, __v_20, __v_19, __v_31, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; - let __v_32: G = __r_arr[0]; - let __v_33: G = G::from_u64(1); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; - let __v_34: G = __r_arr[0]; - let __v_35: G = __r_arr[1]; - match __v_34.as_canonical_u64() { + let __v_30: G = G::from_u64(0); + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_25, __v_0, __v_20, __v_19, __v_30, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; 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_31: G = __r_arr[0]; + let __v_32: G = G::from_u64(1); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_32]; 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_33: G = __r_arr[0]; + match __v_33.as_canonical_u64() { _ => { - let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_32, __v_0, __v_20, __v_19, __v_36, __v_18, __v_15, __v_16, __v_17, __v_34, __v_6, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __v_34: G = G::from_u64(0); + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_31, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_33, __v_6, __v_3, __v_4]; let __cu = unconstrained; 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_35: G = __r_arr[0]; + let __v_36: G = G::from_u64(2); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_36]; 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_37: G = __r_arr[0]; - let __v_38: G = G::from_u64(2); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; - let __v_39: G = __r_arr[0]; - let __v_40: G = __r_arr[1]; - match __v_39.as_canonical_u64() { + match __v_37.as_canonical_u64() { _ => { - let __v_41: G = G::from_u64(0); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_37, __v_0, __v_20, __v_19, __v_41, __v_18, __v_15, __v_16, __v_17, __v_39, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; - let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_42, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; - let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_43, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; - let __v_44: G = __r_arr[0]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_43.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; - let __v_45: G = __loaded[0]; - let __v_46: G = __loaded[1]; - let __v_47: G = __loaded[2]; - let __v_48: G = __loaded[3]; - let __v_49: G = __loaded[4]; - let __v_50: G = __loaded[5]; - let __v_51: G = __loaded[6]; - match __v_45.as_canonical_u64() { + let __v_38: G = G::from_u64(0); + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_35, __v_0, __v_20, __v_19, __v_38, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __v_4]; let __cu = unconstrained; 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_39: G = __r_arr[0]; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_39, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; 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_40: G = __r_arr[0]; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_40, __v_19]; 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_41: G = __r_arr[0]; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_42: G = __loaded[0]; + let __v_43: G = __loaded[1]; + let __v_44: G = __loaded[2]; + let __v_45: G = __loaded[3]; + let __v_46: G = __loaded[4]; + let __v_47: G = __loaded[5]; + let __v_48: G = __loaded[6]; + match __v_42.as_canonical_u64() { 0u64 => { - match __v_46.as_canonical_u64() { + match __v_43.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_49, __v_50, __v_21, __v_22, __v_2, __v_0, __v_20, __v_51, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; - let __v_52: G = __r_arr[0]; - let __v_53: G = __r_arr[1]; - let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_23, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_46, __v_47, __v_21, __v_22, __v_2, __v_0, __v_20, __v_48, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __v_51: G = __r_arr[2]; + let __v_52: G = G::from_u64(0); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_23, __v_52]; 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_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2]; 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_55: G = __r_arr[0]; - let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; - let __v_57: G = __r_arr[0]; - let __v_58: G = (__v_57 - __v_24); - let __v_59: G = G::from_bool((__v_58 == G::ZERO)); - let __v_60: G = G::from_u64(1); - if (__v_59 != __v_60) { - return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None }); + let __v_56: G = (__v_55 - __v_24); + let __v_57: G = G::from_bool((__v_56 == G::ZERO)); + let __v_58: G = G::from_u64(1); + if (__v_57 != __v_58) { + return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_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_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_59: G = __r_arr[0]; + let __v_60: G = G::from_u64(3); + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_8, __v_9]; 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_61: G = __r_arr[0]; - let __v_62: G = G::from_u64(3); - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; - let __v_63: G = __r_arr[0]; - let __v_64: G = (__v_62 + __v_63); - let __v_65: G = (__v_61 - __v_64); - let __v_66: G = G::from_bool((__v_65 == G::ZERO)); - let __v_67: G = G::from_u64(1); - if (__v_66 != __v_67) { - return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None }); + let __v_62: G = (__v_60 + __v_61); + let __v_63: G = (__v_59 - __v_62); + let __v_64: G = G::from_bool((__v_63 == G::ZERO)); + let __v_65: G = G::from_u64(1); + if (__v_64 != __v_65) { + return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_68: G = __r_arr[0]; - let __v_69: G = (__v_68 - __v_18); - let __v_70: G = G::from_bool((__v_69 == G::ZERO)); - let __v_71: G = G::from_u64(1); - if (__v_70 != __v_71) { - return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_29]; 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_66: G = __r_arr[0]; + let __v_67: G = (__v_66 - __v_18); + let __v_68: G = G::from_bool((__v_67 == G::ZERO)); + let __v_69: G = G::from_u64(1); + if (__v_68 != __v_69) { + return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_10, __v_29, __v_27, __v_0, __v_30, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; - let __v_72: G = __r_arr[0]; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_33]; 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_70: G = __r_arr[0]; + let __v_71: G = (__v_70 - __v_18); + let __v_72: G = G::from_bool((__v_71 == G::ZERO)); let __v_73: G = G::from_u64(1); if (__v_72 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_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_205] = { let __args: [G; IN_205] = [__v_37]; 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_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,50 +13806,29 @@ 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 __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 __v_78: G = (__v_43 - __v_20); + let __v_79: G = G::from_bool((__v_78 == G::ZERO)); + let __v_80: G = G::from_u64(1); + if (__v_79 != __v_80) { + return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_80.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_80: G = __r_arr[0]; - let __v_81: G = (__v_80 - __v_18); + let __v_81: G = (__v_53 - __v_49); let __v_82: G = G::from_bool((__v_81 == G::ZERO)); - let __v_83: G = G::from_u64(1); - if (__v_82 != __v_83) { - return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_83.as_canonical_u64(), msg: None }); - } - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_12, __v_39, __v_27, __v_0, __v_40, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; - let __v_84: G = __r_arr[0]; - let __v_85: G = G::from_u64(1); - if (__v_84 != __v_85) { - return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_85.as_canonical_u64(), msg: None }); + let __v_83: G = (__v_54 - __v_50); + let __v_84: G = G::from_bool((__v_83 == G::ZERO)); + let __v_85: G = (__v_82 * __v_84); + let __v_86: G = G::from_u64(1); + if (__v_85 != __v_86) { + return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_86.as_canonical_u64(), msg: None }); } - let __v_86: G = (__v_46 - __v_20); - let __v_87: G = G::from_bool((__v_86 == G::ZERO)); - let __v_88: G = G::from_u64(1); - if (__v_87 != __v_88) { - return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None }); - } - let __v_89: G = (__v_55 - __v_52); - let __v_90: G = G::from_bool((__v_89 == G::ZERO)); - let __v_91: G = (__v_56 - __v_53); - let __v_92: G = G::from_bool((__v_91 == G::ZERO)); - let __v_93: G = (__v_90 * __v_92); - let __v_94: G = G::from_u64(1); - if (__v_93 != __v_94) { - return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_94.as_canonical_u64(), msg: None }); - } - let __v_95: G = G::from_u64(1); - let __ret: [G; OUT_141] = [__v_95]; - if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_145] = [__v_51]; + 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_45.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_42.as_canonical_u64())); }, } }, @@ -13457,15 +13842,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_146: usize = 25; +const IN_146: usize = 25; +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_142], 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]; @@ -13499,40 +13884,511 @@ fn aiur_fn_142( let __v_28: G = __loaded[3]; match __v_25.as_canonical_u64() { 1u64 => { - let __v_29: G = G::from_u64(1); - let __ret: [G; OUT_142] = [__v_29]; - if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_29: G = G::from_u64(1); + let __v_30: G = G::from_u64(1); + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_146] = [__v_31]; + 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); + }, + 0u64 => { + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __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_145] = { let __args: [G; IN_145] = [__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[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_32: G = __r_arr[0]; + let __v_33: G = G::from_u64(0); + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__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[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_35]; + 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); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_147: usize = 4; +const IN_147: usize = 4; +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 = 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_147] = [__v_6]; + 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); + }, + _ => { + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = __r_arr[2]; + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_2 - __v_8); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_147] = [__v_11]; + 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 = 2; +const IN_148: usize = 2; +const OUT_148: usize = 1; +fn aiur_fn_148( + inp: [G; IN_148], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_148], 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; 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_148] = [__v_8]; + 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 => { + match __v_3.as_canonical_u64() { + _ => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__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_148] = { let __args: [G; IN_148] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_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_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_149: usize = 2; +const IN_149: usize = 2; +const OUT_149: usize = 1; +fn aiur_fn_149( + inp: [G; IN_149], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_149], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(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_149] = [__v_9]; + 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); + }, + 0u64 => { + match __v_3.as_canonical_u64() { + _ => { + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__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_8: G = __r_arr[0]; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_10]; + 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); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_150: usize = 4; +const IN_150: usize = 4; +const OUT_150: usize = 1; +fn aiur_fn_150( + inp: [G; IN_150], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_150], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_150] = [__v_6]; + 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); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_1, __v_2]; 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_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_2 + __v_7); + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_3 - __v_9); + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_150] = [__v_12]; + 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 = 13; +const IN_151: usize = 13; +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 __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_9, __v_11, __v_10, __v_13]; 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_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_15]; 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_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + match __v_16.as_canonical_u64() { + _ => { + let __v_18: G = G::from_u64(1); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_18]; 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_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + match __v_19.as_canonical_u64() { + _ => { + let __v_21: G = G::from_u64(2); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_21]; 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_22: G = __r_arr[0]; + let __v_23: G = __r_arr[1]; + match __v_22.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2, __v_16, __v_14, __v_1, __v_17, __v_12]; 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_24: G = __r_arr[0]; + let __v_25: G = G::from_u64(1); + if (__v_24 != __v_25) { + return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_3, __v_19, __v_14, __v_1, __v_20, __v_12]; 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_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(1); + if (__v_26 != __v_27) { + return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_4, __v_22, __v_14, __v_1, __v_23, __v_12]; 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_28: G = __r_arr[0]; + let __v_29: G = G::from_u64(1); + if (__v_28 != __v_29) { + return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None }); + } + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_30: G = G::from_u64(1); + let __ret: [G; OUT_151] = [__v_30]; + 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); + }, + 1u64 => { + let __v_30: G = G::from_u64(3); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_30]; 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_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + match __v_31.as_canonical_u64() { + _ => { + let __v_33: G = G::from_u64(0); + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_9, __v_11, __v_8, __v_10, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_34]; 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_35: G = __r_arr[0]; + let __v_36: G = (__v_12 - __v_35); + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __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_37: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5, __v_31, __v_34, __v_37, __v_32, __v_35]; 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_38: G = __r_arr[0]; + let __ret: [G; OUT_151] = [__v_38]; + 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_6.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_0]; + 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 __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3, __v_1]; 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_6: G = __r_arr[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_7: G = __r_arr[0]; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_152] = [__v_8]; + 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 = 1; +fn aiur_fn_153( + inp: [G; IN_153], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_153], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_153] = [__v_7]; + 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); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__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 __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_4, __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_12: G = __r_arr[0]; + let __v_13: G = { let __values: [G; 3] = [__v_5, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_13]; + 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_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_154: usize = 6; +const IN_154: usize = 6; +const OUT_154: usize = 1; +fn aiur_fn_154( + inp: [G; IN_154], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_154], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_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_11: G = __r_arr[0]; + let __v_12: G = G::from_bool((__v_11 == G::ZERO)); + let __ret: [G; OUT_154] = [__v_12]; + if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; - let __v_29: G = __r_arr[0]; - let __v_30: G = __r_arr[1]; - let __v_31: G = __r_arr[2]; - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; - let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; - let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_142] = [__v_33]; - if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + match __v_11.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + _ => { + let __v_14: G = G::from_u64(1); + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_3, __v_14]; 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_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_5 - __v_16); + let __v_18: G = G::from_u64(1); + if (__v_7 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8]; 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_19: G = __r_arr[0]; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__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 __v_20: G = __r_arr[0]; + if (__v_19 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_2, __v_4]; 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_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 3] = [__v_22, __v_17, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_12, __v_21, __v_26, __v_15, __v_9, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = G::from_u64(1); + if (__v_27 != __v_28) { + return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None }); + } + let __v_29: G = G::from_u64(1); + let __v_30: G = (__v_4 + __v_29); + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_10, __v_13, __v_2, __v_15, __v_30, __v_17]; 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_31: G = __r_arr[0]; + let __ret: [G; OUT_154] = [__v_31]; + 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); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } }, _ => { - return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); }, } }) } -const INPUT_SIZE_143: usize = 31; -const IN_143: usize = 31; -const OUT_143: usize = 1; -fn aiur_fn_143( - inp: [G; IN_143], +const INPUT_SIZE_155: usize = 32; +const IN_155: usize = 32; +const OUT_155: usize = 1; +fn aiur_fn_155( + inp: [G; IN_155], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_143], 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]; @@ -13565,184 +14421,208 @@ fn aiur_fn_143( let __v_28: G = inp[28]; let __v_29: G = inp[29]; let __v_30: G = inp[30]; + let __v_31: G = inp[31]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_31: G = __r_arr[0]; - let __v_32: G = G::from_u64(1); + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_6]; 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_32: G = __r_arr[0]; 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 __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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() { 0u64 => { - break '__mc_0 [__v_34]; + break '__mc_0 [__v_35]; }, 1u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_35: G = __r_arr[0]; - break '__mc_0 [__v_35]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_5, __v_35]; 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_36: G = __r_arr[0]; + break '__mc_0 [__v_36]; }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }; - let __v_35: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_36]; 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_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_122] = { let __args: [G; IN_122] = [__v_2, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __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_122] = { let __args: [G; IN_122] = [__v_1, __v_38]; 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_39: G = __r_arr[0]; - let __v_40: G = G::from_u64(1); + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_39]; 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_40: G = __r_arr[0]; let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_43: G = __r_arr[0]; - let __v_44: G = __r_arr[1]; - let __v_45: G = __r_arr[2]; - let __v_46: G = __r_arr[3]; - let __v_47: G = __r_arr[4]; - let __v_48: G = __r_arr[5]; - let __v_49: G = __r_arr[6]; - let __v_50: G = __r_arr[7]; - let __v_51: G = __r_arr[8]; - let __v_52: G = __r_arr[9]; - let __v_53: G = __r_arr[10]; - let __v_54: G = __r_arr[11]; - let __v_55: G = __r_arr[12]; - let __v_56: G = __r_arr[13]; - let __v_57: G = __r_arr[14]; - let __v_58: G = __r_arr[15]; - let __v_59: G = __r_arr[16]; - let __v_60: G = __r_arr[17]; - let __v_61: G = G::from_u64(256); - let __v_62: G = (__v_61 * __v_44); - let __v_63: G = G::from_u64(65536); - let __v_64: G = (__v_63 * __v_45); - let __v_65: G = G::from_u64(16777216); - let __v_66: G = (__v_65 * __v_46); - let __v_67: G = G::from_u64(4294967296); - let __v_68: G = (__v_67 * __v_47); - let __v_69: G = G::from_u64(1099511627776); - let __v_70: G = (__v_69 * __v_48); - let __v_71: G = G::from_u64(281474976710656); - let __v_72: G = (__v_71 * __v_49); - let __v_73: G = G::from_u64(72057594037927936); - let __v_74: G = (__v_73 * __v_50); - let __v_75: G = (__v_72 + __v_74); - let __v_76: G = (__v_70 + __v_75); - let __v_77: G = (__v_68 + __v_76); - let __v_78: G = (__v_66 + __v_77); - let __v_79: G = (__v_64 + __v_78); - let __v_80: G = (__v_62 + __v_79); - let __v_81: G = (__v_43 + __v_80); - let __v_82: G = G::from_u64(256); - let __v_83: G = (__v_82 * __v_52); - let __v_84: G = G::from_u64(65536); - let __v_85: G = (__v_84 * __v_53); - let __v_86: G = G::from_u64(16777216); - let __v_87: G = (__v_86 * __v_54); - let __v_88: G = G::from_u64(4294967296); - let __v_89: G = (__v_88 * __v_55); - let __v_90: G = G::from_u64(1099511627776); - let __v_91: G = (__v_90 * __v_56); - let __v_92: G = G::from_u64(281474976710656); - let __v_93: G = (__v_92 * __v_57); - let __v_94: G = G::from_u64(72057594037927936); - let __v_95: G = (__v_94 * __v_58); - let __v_96: G = (__v_93 + __v_95); - let __v_97: G = (__v_91 + __v_96); - let __v_98: G = (__v_89 + __v_97); - let __v_99: G = (__v_87 + __v_98); - let __v_100: G = (__v_85 + __v_99); - let __v_101: G = (__v_83 + __v_100); - let __v_102: G = (__v_51 + __v_101); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_59, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; - let __v_103: G = __r_arr[0]; - let __v_104: G = __r_arr[1]; - let __v_105: G = G::from_u64(1); + let __v_42: G = G::from_u64(1); + let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_40, __v_43]; 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_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __v_47: G = __r_arr[3]; + let __v_48: G = __r_arr[4]; + let __v_49: G = __r_arr[5]; + let __v_50: G = __r_arr[6]; + let __v_51: G = __r_arr[7]; + let __v_52: G = __r_arr[8]; + let __v_53: G = __r_arr[9]; + let __v_54: G = __r_arr[10]; + let __v_55: G = __r_arr[11]; + let __v_56: G = __r_arr[12]; + let __v_57: G = __r_arr[13]; + let __v_58: G = __r_arr[14]; + let __v_59: G = __r_arr[15]; + let __v_60: G = __r_arr[16]; + let __v_61: G = __r_arr[17]; + let __v_62: G = G::from_u64(256); + let __v_63: G = (__v_62 * __v_45); + let __v_64: G = G::from_u64(65536); + let __v_65: G = (__v_64 * __v_46); + let __v_66: G = G::from_u64(16777216); + let __v_67: G = (__v_66 * __v_47); + let __v_68: G = G::from_u64(4294967296); + let __v_69: G = (__v_68 * __v_48); + let __v_70: G = G::from_u64(1099511627776); + let __v_71: G = (__v_70 * __v_49); + let __v_72: G = G::from_u64(281474976710656); + let __v_73: G = (__v_72 * __v_50); + let __v_74: G = G::from_u64(72057594037927936); + let __v_75: G = (__v_74 * __v_51); + let __v_76: G = (__v_73 + __v_75); + let __v_77: G = (__v_71 + __v_76); + let __v_78: G = (__v_69 + __v_77); + let __v_79: G = (__v_67 + __v_78); + let __v_80: G = (__v_65 + __v_79); + let __v_81: G = (__v_63 + __v_80); + let __v_82: G = (__v_44 + __v_81); + let __v_83: G = G::from_u64(256); + let __v_84: G = (__v_83 * __v_53); + let __v_85: G = G::from_u64(65536); + let __v_86: G = (__v_85 * __v_54); + let __v_87: G = G::from_u64(16777216); + let __v_88: G = (__v_87 * __v_55); + let __v_89: G = G::from_u64(4294967296); + let __v_90: G = (__v_89 * __v_56); + let __v_91: G = G::from_u64(1099511627776); + let __v_92: G = (__v_91 * __v_57); + let __v_93: G = G::from_u64(281474976710656); + let __v_94: G = (__v_93 * __v_58); + let __v_95: G = G::from_u64(72057594037927936); + let __v_96: G = (__v_95 * __v_59); + let __v_97: G = (__v_94 + __v_96); + let __v_98: G = (__v_92 + __v_97); + let __v_99: G = (__v_90 + __v_98); + let __v_100: G = (__v_88 + __v_99); + let __v_101: G = (__v_86 + __v_100); + let __v_102: G = (__v_84 + __v_101); + let __v_103: G = (__v_52 + __v_102); + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_60, __v_6, __v_7, __v_30]; 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_104: G = __r_arr[0]; + let __v_105: G = __r_arr[1]; let __v_106: G = G::from_u64(1); - let __v_107: G = { let __values: [G; 3] = [__v_105, __v_106, __v_106]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; - let __v_108: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_104, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_107: G = G::from_u64(1); + let __v_108: G = { let __values: [G; 3] = [__v_106, __v_107, __v_107]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_10, __v_108]; 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_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_207] = { let __args: [G; IN_207] = [__v_105, __v_109]; 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_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_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_111: G = __r_arr[0]; - let __v_112: G = __r_arr[1]; - let __v_113: G = (__v_31 + __v_27); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_114: G = __r_arr[0]; - let __v_115: G = (__v_114 - __v_31); - let __v_116: G = G::from_bool((__v_115 == G::ZERO)); - let __v_117: G = G::from_u64(1); - if (__v_116 != __v_117) { - return Err(ExecError::AssertEqMismatch { lhs: __v_116.as_canonical_u64(), rhs: __v_117.as_canonical_u64(), msg: None }); - } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_111, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; 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_112: G = __r_arr[0]; + let __v_113: G = __r_arr[1]; + let __v_114: G = (__v_32 + __v_28); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_112, __v_113, __v_29, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_115: G = __r_arr[0]; + let __v_116: G = G::from_u64(0); + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_8, __v_9, __v_116, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_117: G = __r_arr[0]; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_112, __v_113, __v_117, __v_82, __v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_114, __v_104, __v_6, __v_10, __v_32]; let __cu = unconstrained; 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_118: G = __r_arr[0]; - let __v_119: G = (__v_118 - __v_28); - let __v_120: G = G::from_bool((__v_119 == G::ZERO)); - let __v_121: G = G::from_u64(1); - if (__v_120 != __v_121) { - return Err(ExecError::AssertEqMismatch { lhs: __v_120.as_canonical_u64(), rhs: __v_121.as_canonical_u64(), msg: None }); - } - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; - let __v_122: G = __r_arr[0]; - let __v_123: G = G::from_u64(1); - if (__v_122 != __v_123) { - return Err(ExecError::AssertEqMismatch { lhs: __v_122.as_canonical_u64(), rhs: __v_123.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7]; 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 __v_119: G = __r_arr[0]; + let __v_120: G = (__v_119 - __v_32); + let __v_121: G = G::from_bool((__v_120 == G::ZERO)); + let __v_122: G = G::from_u64(1); + if (__v_121 != __v_122) { + return Err(ExecError::AssertEqMismatch { lhs: __v_121.as_canonical_u64(), rhs: __v_122.as_canonical_u64(), msg: None }); } - let __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_206] = { let __args: [G; IN_206] = [__v_8]; 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_123: G = __r_arr[0]; + let __v_124: G = G::from_u64(3); + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_4, __v_5]; 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_125: G = __r_arr[0]; + let __v_126: G = (__v_124 + __v_125); + if (__v_123 != __v_126) { + return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_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_215] = { let __args: [G; IN_215] = [__v_9]; 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_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 __v_128: G = (__v_127 - __v_32); + let __v_129: G = G::from_bool((__v_128 == G::ZERO)); + let __v_130: G = G::from_u64(1); + if (__v_129 != __v_130) { + return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_130.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_10]; 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_131: G = __r_arr[0]; + let __v_132: G = G::from_u64(1); + if (__v_131 != __v_132) { + return Err(ExecError::AssertEqMismatch { lhs: __v_131.as_canonical_u64(), rhs: __v_132.as_canonical_u64(), msg: None }); + } + let __v_133: G = G::from_u64(33); + let __v_134: G = { let __a_val = __v_114.as_canonical_u64(); let __b_val = __v_133.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_135: G = G::from_u64(1); + if (__v_134 != __v_135) { + return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_135.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_8, __v_115, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_114]; let __cu = unconstrained; 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_136: G = __r_arr[0]; + let __v_137: G = G::from_u64(1); + if (__v_136 != __v_137) { + return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_137.as_canonical_u64(), msg: None }); + } + let __v_138: G = G::from_u64(0); + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_9, __v_6, __v_118, __v_115, __v_138, __v_114]; 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_139: G = __r_arr[0]; + let __ret: [G; OUT_155] = [__v_139]; + 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_144: usize = 2; -const IN_144: usize = 2; -const OUT_144: usize = 1; -fn aiur_fn_144( - inp: [G; IN_144], +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_144], 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]; 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_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); }) } -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_157: usize = 1; +const IN_157: usize = 1; +const OUT_157: usize = 1; +fn aiur_fn_157( + inp: [G; IN_157], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_145], ExecError> { +) -> Result<[G; OUT_157], 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 +14633,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_157] = [__v_5]; + 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); }, 0u64 => { @@ -13768,15 +14648,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_157] = [__v_11]; + if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __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_157] = { let __args: [G; IN_157] = [__v_4]; 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_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_157] = [__v_9]; + 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); }, } @@ -13788,15 +14668,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_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_146], 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]; @@ -13823,21 +14703,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_158] = [__v_24]; + 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_147: usize = 33; -const IN_147: usize = 33; -const OUT_147: usize = 1; -fn aiur_fn_147( - inp: [G; IN_147], +const INPUT_SIZE_159: usize = 33; +const IN_159: usize = 33; +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_147], 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]; @@ -13872,29 +14752,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_158] = { let __args: [G; IN_158] = [__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[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_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_158] = { let __args: [G; IN_158] = [__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[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_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_158] = { let __args: [G; IN_158] = [__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[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_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_158] = { let __args: [G; IN_158] = [__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[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_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_159] = [__v_36]; + 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_148: usize = 2; -const IN_148: usize = 2; -const OUT_148: usize = 1; -fn aiur_fn_148( - inp: [G; IN_148], +const INPUT_SIZE_160: usize = 2; +const IN_160: usize = 2; +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_148], ExecError> { +) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13904,8 +14784,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_160] = [__v_1]; + 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); }, 0u64 => { @@ -13942,18 +14822,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_160] = { let __args: [G; IN_160] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __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_158] = { let __args: [G; IN_158] = [__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[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_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_158] = { let __args: [G; IN_158] = [__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[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_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_158] = { let __args: [G; IN_158] = [__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[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_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_158] = { let __args: [G; IN_158] = [__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[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_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_160] = [__v_41]; + 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); }, _ => { @@ -13963,15 +14843,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_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_149], 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]; @@ -13981,8 +14861,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_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 => { @@ -13993,12 +14873,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_161] = { let __args: [G; IN_161] = [__v_4, __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_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_158] = { let __args: [G; IN_158] = [__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[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 __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_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); }, _ => { @@ -14008,15 +14888,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_162: usize = 2; +const IN_162: usize = 2; +const OUT_162: usize = 10; +fn aiur_fn_162( + inp: [G; IN_162], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_150], 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]; @@ -14133,7 +15013,7 @@ fn aiur_fn_150( 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_115] = { let __args: [G; IN_115] = [__v_98, __v_101]; 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_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 +15063,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_162] = [__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[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); }, _ => { @@ -14270,8 +15150,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_162] = [__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[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); }, _ => { @@ -14316,19 +15196,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_163: usize = 2; +const IN_163: usize = 2; +const OUT_163: usize = 10; +fn aiur_fn_163( + inp: [G; IN_163], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_151], 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]; - 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_162] = { let __args: [G; IN_162] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14356,12 +15236,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_163] = [__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[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); }, _ => { - 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_163] = { let __args: [G; IN_163] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; @@ -14372,27 +15252,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_163] = [__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[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_152: usize = 2; -const IN_152: usize = 2; -const OUT_152: usize = 18; -fn aiur_fn_152( - inp: [G; IN_152], +const INPUT_SIZE_164: usize = 2; +const IN_164: usize = 2; +const OUT_164: usize = 18; +fn aiur_fn_164( + inp: [G; IN_164], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_152], 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 __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_163] = { let __args: [G; IN_163] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -14403,7 +15283,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_163] = { let __args: [G; IN_163] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -14414,21 +15294,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_164] = [__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[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_153: usize = 2; -const IN_153: usize = 2; -const OUT_153: usize = 1; -fn aiur_fn_153( - inp: [G; IN_153], +const INPUT_SIZE_165: usize = 2; +const IN_165: usize = 2; +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_153], ExecError> { +) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14437,8 +15317,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_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); }, _ => { @@ -14451,11 +15331,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_165] = { let __args: [G; IN_165] = [__v_4, __v_7]; 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_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_165] = [__v_9]; + 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); }, _ => { @@ -14467,20 +15347,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_166: usize = 3; +const IN_166: usize = 3; +const OUT_166: usize = 3; +fn aiur_fn_166( + inp: [G; IN_166], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_154], 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_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_162] = { let __args: [G; IN_162] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -14530,31 +15410,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_158] = { let __args: [G; IN_158] = [__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[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_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_158] = { let __args: [G; IN_158] = [__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[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_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_158] = { let __args: [G; IN_158] = [__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[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_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_158] = { let __args: [G; IN_158] = [__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[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_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_165] = { let __args: [G; IN_165] = [__v_51, __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_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_166] = [__v_52, __v_11, __v_12]; + 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_155: usize = 9; -const IN_155: usize = 9; -const OUT_155: usize = 1; -fn aiur_fn_155( - inp: [G; IN_155], +const INPUT_SIZE_167: usize = 9; +const IN_167: usize = 9; +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_155], ExecError> { +) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14568,50 +15448,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_158] = { let __args: [G; IN_158] = [__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[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_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_207] = { let __args: [G; IN_207] = [__v_0, __v_12]; 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_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_167] = [__v_13]; + 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_156: usize = 2; -const IN_156: usize = 2; -const OUT_156: usize = 1; -fn aiur_fn_156( - inp: [G; IN_156], +const INPUT_SIZE_168: usize = 2; +const IN_168: usize = 2; +const OUT_168: usize = 1; +fn aiur_fn_168( + inp: [G; IN_168], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_156], 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 = 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_160] = { let __args: [G; IN_160] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __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_207] = { let __args: [G; IN_207] = [__v_0, __v_5]; 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_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_168] = [__v_6]; + 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_157: usize = 1; -const IN_157: usize = 1; -const OUT_157: usize = 1; -fn aiur_fn_157( - inp: [G; IN_157], +const INPUT_SIZE_169: usize = 1; +const IN_169: usize = 1; +const OUT_169: usize = 1; +fn aiur_fn_169( + inp: [G; IN_169], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_157], ExecError> { +) -> Result<[G; OUT_169], 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 +15536,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_169] = [__v_42]; + 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_158: usize = 2; -const IN_158: usize = 2; -const OUT_158: usize = 1; -fn aiur_fn_158( - inp: [G; IN_158], +const INPUT_SIZE_170: usize = 2; +const IN_170: usize = 2; +const OUT_170: usize = 1; +fn aiur_fn_170( + inp: [G; IN_170], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_158], 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]; @@ -14687,17 +15567,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_170] = [__v_1]; + 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); }, 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_170] = { let __args: [G; IN_170] = [__v_11, __v_1]; 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_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_158] = { let __args: [G; IN_158] = [__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[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 __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_170] = [__v_13]; + 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); }, _ => { @@ -14707,15 +15587,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_171: usize = 2; +const IN_171: usize = 2; +const OUT_171: usize = 1; +fn aiur_fn_171( + inp: [G; IN_171], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_159], 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]; @@ -14724,13 +15604,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_171] = [__v_4]; + 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); }, 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_171] = [__v_1]; + if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -14740,15 +15620,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_172: usize = 9; +const IN_172: usize = 9; +const OUT_172: usize = 9; +fn aiur_fn_172( + inp: [G; IN_172], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_160], ExecError> { +) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14759,15 +15639,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_161] = { let __args: [G; IN_161] = [__v_6, __v_7]; 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_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_160] = { let __args: [G; IN_160] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __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_160] = { let __args: [G; IN_160] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __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_161] = { let __args: [G; IN_161] = [__v_1, __v_11]; 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_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_170] = { let __args: [G; IN_170] = [__v_0, __v_12]; 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_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(109); @@ -14814,7 +15694,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_164] = { let __args: [G; IN_164] = [__v_55, __v_58]; 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_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; @@ -14836,16 +15716,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_158] = { let __args: [G; IN_158] = [__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[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_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_158] = { let __args: [G; IN_158] = [__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[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_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_207] = { let __args: [G; IN_207] = [__v_75, __v_81]; 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_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_164] = { let __args: [G; IN_164] = [__v_82, __v_85]; 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_86: G = __r_arr[0]; let __v_87: G = __r_arr[1]; let __v_88: G = __r_arr[2]; @@ -14867,25 +15747,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_158] = { let __args: [G; IN_158] = [__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[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_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_158] = { let __args: [G; IN_158] = [__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[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_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_207] = { let __args: [G; IN_207] = [__v_102, __v_108]; 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_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_168] = { let __args: [G; IN_168] = [__v_109, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_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_120] = { let __args: [G; IN_120] = [__v_8, __v_113]; 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_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_207] = { let __args: [G; IN_207] = [__v_110, __v_114]; 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_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_164] = { let __args: [G; IN_164] = [__v_115, __v_118]; 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_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __v_121: G = __r_arr[2]; @@ -14904,12 +15784,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_168] = { let __args: [G; IN_168] = [__v_135, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_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_164] = { let __args: [G; IN_164] = [__v_137, __v_140]; 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_141: G = __r_arr[0]; let __v_142: G = __r_arr[1]; let __v_143: G = __r_arr[2]; @@ -15096,29 +15976,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_172] = [__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[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); }) } -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_173: usize = 3; +const IN_173: usize = 3; +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_161], 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]; 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_173] = [__v_0, __v_1]; + 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); }, _ => { @@ -15132,135 +16012,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_173] = { let __args: [G; IN_173] = [__v_7, __v_10, __v_12]; 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_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_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); }, } }) } -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_174: usize = 1; +const IN_174: usize = 1; +const OUT_174: usize = 1; +fn aiur_fn_174( + inp: [G; IN_174], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_162], ExecError> { +) -> Result<[G; OUT_174], 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_174] = [__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); }, 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_174] = [__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); }, _ => { 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_174] = { let __args: [G; IN_174] = [__v_2]; 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_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_174] = [__v_4]; + 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); }, } }) } -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_175: usize = 3; +const IN_175: usize = 3; +const OUT_175: usize = 2; +fn aiur_fn_175( + inp: [G; IN_175], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_163], 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]; 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_173] = { let __args: [G; IN_173] = [__v_0, __v_1, __v_2]; 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_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_175] = [__v_7, __v_8]; + 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_164: usize = 1; -const IN_164: usize = 1; -const OUT_164: usize = 1; -fn aiur_fn_164( - inp: [G; IN_164], +const INPUT_SIZE_176: usize = 1; +const IN_176: usize = 1; +const OUT_176: usize = 1; +fn aiur_fn_176( + inp: [G; IN_176], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_164], ExecError> { +) -> Result<[G; OUT_176], 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_176] = [__v_1]; + 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); }, _ => { 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_176] = { let __args: [G; IN_176] = [__v_3]; 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_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_176] = [__v_5]; + 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); }, } }) } -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_177: usize = 3; +const IN_177: usize = 3; +const OUT_177: usize = 8; +fn aiur_fn_177( + inp: [G; IN_177], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_165], 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]; 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_173] = { let __args: [G; IN_173] = [__v_0, __v_1, __v_2]; 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_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_174] = { let __args: [G; IN_174] = [__v_2]; 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_9: G = __r_arr[0]; let __v_10: G = g_inverse_value(__v_9); let __v_11: G = (__v_9 * __v_10); @@ -15371,21 +16251,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_177] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94]; + 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); }) } -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_178: usize = 24; +const IN_178: usize = 24; +const OUT_178: usize = 1; +fn aiur_fn_178( + inp: [G; IN_178], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_166], 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]; @@ -15410,54 +16290,55 @@ fn aiur_fn_166( let __v_20: G = inp[20]; let __v_21: G = inp[21]; let __v_22: G = inp[22]; + let __v_23: G = inp[23]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; - let __v_23: G = __r_arr[0]; - let __v_24: G = G::from_bool((__v_23 == G::ZERO)); - let __v_25: G = G::from_u64(0); - if (__v_24 != __v_25) { - return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None }); - } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_26: G = __r_arr[0]; - if (__v_26 != __v_23) { - return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4]; 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_24: G = __r_arr[0]; + let __v_25: G = G::from_bool((__v_24 == G::ZERO)); + let __v_26: G = G::from_u64(0); + if (__v_25 != __v_26) { + return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_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_205] = { let __args: [G; IN_205] = [__v_22]; 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_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 }); + if (__v_27 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_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_205] = { let __args: [G; IN_205] = [__v_23]; 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_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 }); + if (__v_28 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_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_205] = { let __args: [G; IN_205] = [__v_19]; 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_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 }); + if (__v_29 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_4]; 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_30: G = __r_arr[0]; 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)); }; + if (__v_30 != __v_31) { + return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); + } + let __v_32: G = G::from_u64(1); + let __ret: [G; OUT_178] = [__v_32]; + if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; 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_179: usize = 6; +const IN_179: usize = 6; +const OUT_179: usize = 2; +fn aiur_fn_179( + inp: [G; IN_179], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_167], 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]; @@ -15475,21 +16356,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_179] = [__v_14, __v_15]; + 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_168: usize = 4; -const IN_168: usize = 4; -const OUT_168: usize = 2; -fn aiur_fn_168( - inp: [G; IN_168], +const INPUT_SIZE_180: usize = 4; +const IN_180: usize = 4; +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_168], 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]; @@ -15507,21 +16388,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_180] = [__v_14, __v_15]; + 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); }) } -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_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_169], ExecError> { +) -> Result<[G; OUT_181], 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 +16415,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_181] = [__v_7]; + 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); }, 0u64 => { @@ -15547,14 +16428,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_180] = { let __args: [G; IN_180] = [__v_2, __v_3, __v_6, __v_7]; 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_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_181] = { let __args: [G; IN_181] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_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_181] = [__v_13]; + 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); }, _ => { @@ -15569,15 +16450,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_182: usize = 15; +const IN_182: usize = 15; +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_170], 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]; @@ -15594,7 +16475,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_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_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -15602,8 +16483,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_182] = [__v_16, __v_19]; + 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 => { @@ -15611,109 +16492,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_213] = { let __args: [G; IN_213] = [__v_4, __v_18]; 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_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_182] = [__v_21, __v_22]; + 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_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_213] = { let __args: [G; IN_213] = [__v_5, __v_18]; 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_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_182] = [__v_21, __v_22]; + 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); }, 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_213] = { let __args: [G; IN_213] = [__v_2, __v_18]; 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_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_182] = [__v_21, __v_22]; + 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); }, 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_213] = { let __args: [G; IN_213] = [__v_3, __v_18]; 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_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_182] = [__v_21, __v_22]; + 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); }, 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_213] = { let __args: [G; IN_213] = [__v_6, __v_18]; 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_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_182] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __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_213] = { let __args: [G; IN_213] = [__v_7, __v_18]; 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_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_182] = [__v_21, __v_22]; + 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); }, } }, 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_213] = { let __args: [G; IN_213] = [__v_8, __v_16]; 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_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_182] = [__v_19, __v_20]; + 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); }, 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_182] = [__v_9, __v_10]; + 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); }, 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_182] = [__v_11, __v_12]; + 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); }, 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_182] = [__v_13, __v_14]; + 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); }, 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_182] = { let __args: [G; IN_182] = [__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[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_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_182] = { let __args: [G; IN_182] = [__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[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_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_182] = [__v_23, __v_24]; + 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); }, 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_182] = { let __args: [G; IN_182] = [__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[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_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_182] = { let __args: [G; IN_182] = [__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[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_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_182] = [__v_23, __v_24]; + 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); }, 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_182] = { let __args: [G; IN_182] = [__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[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_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_182] = { let __args: [G; IN_182] = [__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[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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = (__v_19 * __v_21); @@ -15724,20 +16605,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_182] = [__v_27, __v_30]; + 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); }, 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_182] = { let __args: [G; IN_182] = [__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[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_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_182] = [__v_22, __v_24]; + 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); }, _ => { @@ -15747,15 +16628,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_183: usize = 19; +const IN_183: usize = 19; +const OUT_183: usize = 2; +fn aiur_fn_183( + inp: [G; IN_183], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_171], 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]; @@ -15782,22 +16663,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_183] = [__v_0, __v_1]; + 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 => { - 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_182] = { let __args: [G; IN_182] = [__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[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_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_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __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_183] = { let __args: [G; IN_183] = [__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[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_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_183] = [__v_26, __v_27]; + 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); }, _ => { @@ -15807,15 +16688,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_184: usize = 8; +const IN_184: usize = 8; +const OUT_184: usize = 4; +fn aiur_fn_184( + inp: [G; IN_184], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_172], 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]; @@ -15871,21 +16752,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_184] = [__v_50, __v_51, __v_52, __v_53]; + 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); }) } -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_185: usize = 19; +const IN_185: usize = 19; +const OUT_185: usize = 4; +fn aiur_fn_185( + inp: [G; IN_185], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_173], 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]; @@ -15916,28 +16797,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_185] = [__v_22, __v_23, __v_24, __v_25]; + 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_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_185] = { let __args: [G; IN_185] = [__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[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_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_184] = { let __args: [G; IN_184] = [__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[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_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_182] = { let __args: [G; IN_182] = [__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[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_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_185] = [__v_32, __v_33, __v_28, __v_29]; + 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); }, _ => { @@ -15947,15 +16828,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_186: usize = 44; +const IN_186: usize = 44; +const OUT_186: usize = 2; +fn aiur_fn_186( + inp: [G; IN_186], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_174], 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]; @@ -16008,14 +16889,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_186] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { 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_185] = { let __args: [G; IN_185] = [__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[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_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -16024,10 +16905,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_182] = { let __args: [G; IN_182] = [__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[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_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_184] = { let __args: [G; IN_184] = [__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[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_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -16052,7 +16933,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_184] = { let __args: [G; IN_184] = [__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[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_82: G = __r_arr[0]; let __v_83: G = __r_arr[1]; let __v_84: G = __r_arr[2]; @@ -16063,23 +16944,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_213] = { let __args: [G; IN_213] = [__v_35, __v_89]; 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_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_213] = { let __args: [G; IN_213] = [__v_35, __v_94]; 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_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_213] = { let __args: [G; IN_213] = [__v_36, __v_97]; 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_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_213] = { let __args: [G; IN_213] = [__v_36, __v_102]; 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_103: G = __r_arr[0]; let __v_104: G = __r_arr[1]; let __v_105: G = (__v_103 + __v_20); @@ -16088,23 +16969,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_184] = { let __args: [G; IN_184] = [__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[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_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_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __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_179] = { let __args: [G; IN_179] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __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_186] = [__v_121, __v_122]; + 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); }, _ => { @@ -16113,44 +16994,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_213] = { let __args: [G; IN_213] = [__v_35, __v_91]; 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_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_213] = { let __args: [G; IN_213] = [__v_35, __v_96]; 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_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_213] = { let __args: [G; IN_213] = [__v_35, __v_101]; 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_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_213] = { let __args: [G; IN_213] = [__v_35, __v_106]; 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_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_184] = { let __args: [G; IN_184] = [__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[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_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_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __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_179] = { let __args: [G; IN_179] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_123: G = __r_arr[0]; let __v_124: G = __r_arr[1]; let __v_125: G = G::from_u64(1); @@ -16165,11 +17046,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_186] = { let __args: [G; IN_186] = [__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[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_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_186] = [__v_137, __v_138]; + 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); }, _ => { @@ -16177,11 +17058,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_186] = { let __args: [G; IN_186] = [__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[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_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_186] = [__v_95, __v_96]; + 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); }, } @@ -16197,15 +17078,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_187: usize = 28; +const IN_187: usize = 28; +const OUT_187: usize = 2; +fn aiur_fn_187( + inp: [G; IN_187], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_175], ExecError> { +) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16237,7 +17118,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_183] = { let __args: [G; IN_183] = [__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[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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = G::from_u64(0); @@ -16294,42 +17175,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_213] = { let __args: [G; IN_213] = [__v_9, __v_82]; 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_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_213] = { let __args: [G; IN_213] = [__v_8, __v_85]; 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_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_179] = { let __args: [G; IN_179] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __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_213] = { let __args: [G; IN_213] = [__v_9, __v_94]; 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_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_213] = { let __args: [G; IN_213] = [__v_8, __v_97]; 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_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_179] = { let __args: [G; IN_179] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __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_187] = [__v_104, __v_105]; + 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_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_206] = { let __args: [G; IN_206] = [__v_2]; 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_83: G = __r_arr[0]; let __v_84: G = G::from_u64(0); let __v_85: G = G::from_u64(1); @@ -16340,11 +17221,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_186] = { let __args: [G; IN_186] = [__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[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_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_187] = [__v_93, __v_94]; + 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); }, _ => { @@ -16354,15 +17235,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_188: usize = 8; +const IN_188: usize = 8; +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_176], 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]; @@ -16399,21 +17280,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_188] = [__v_34]; + 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); }) } -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_189: usize = 5; +const IN_189: usize = 5; +const OUT_189: usize = 2; +fn aiur_fn_189( + inp: [G; IN_189], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_177], 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]; @@ -16429,8 +17310,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_189] = [__v_9, __v_10]; + 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 => { @@ -16450,13 +17331,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_189] = { let __args: [G; IN_189] = [__v_8, __v_1, __v_2, __v_21, __v_24]; 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_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_189] = [__v_27, __v_28]; + 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); }, _ => { @@ -16466,145 +17347,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_190: usize = 1; +const IN_190: usize = 1; +const OUT_190: usize = 1; +fn aiur_fn_190( + inp: [G; IN_190], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_178], ExecError> { +) -> Result<[G; OUT_190], 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + 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); }, 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_190] = [__v_1]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_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_190] = [__v_1]; + 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_179: usize = 4; -const IN_179: usize = 4; -const OUT_179: usize = 2; -fn aiur_fn_179( - inp: [G; IN_179], +const INPUT_SIZE_191: usize = 4; +const IN_191: usize = 4; +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_179], 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]; @@ -16618,8 +17499,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_191] = [__v_6, __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); }, 1u64 => { @@ -16631,21 +17512,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_191] = [__v_6, __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); }, 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_204] = { let __args: [G; IN_204] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_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_204] = { let __args: [G; IN_204] = [__v_4, __v_5]; 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_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_204] = { let __args: [G; IN_204] = [__v_4, __v_7]; 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_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_191] = [__v_6, __v_8]; + 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); }, _ => { @@ -16660,15 +17541,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_192: usize = 20; +const IN_192: usize = 20; +const OUT_192: usize = 1; +fn aiur_fn_192( + inp: [G; IN_192], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_180], ExecError> { +) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16702,37 +17583,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_192] = [__v_28]; + 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); }, 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_204] = { let __args: [G; IN_204] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - 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_190] = { let __args: [G; IN_190] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_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_213] = { let __args: [G; IN_213] = [__v_3, __v_9]; 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_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_204] = { let __args: [G; IN_204] = [__v_4, __v_9]; 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_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_204] = { let __args: [G; IN_204] = [__v_32, __v_33]; 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_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_204] = { let __args: [G; IN_204] = [__v_32, __v_35]; 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_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_204] = { let __args: [G; IN_204] = [__v_5, __v_9]; 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_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_204] = { let __args: [G; IN_204] = [__v_37, __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_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_204] = { let __args: [G; IN_204] = [__v_37, __v_40]; 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_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_213] = { let __args: [G; IN_213] = [__v_1, __v_9]; 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_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 +17638,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_204] = { let __args: [G; IN_204] = [__v_7, __v_43]; 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_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_204] = { let __args: [G; IN_204] = [__v_44, __v_45]; 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_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_204] = { let __args: [G; IN_204] = [__v_44, __v_47]; 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_48: G = __r_arr[0]; break '__mc_0 [__v_46, __v_48]; }, @@ -16779,14 +17660,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_173] = { let __args: [G; IN_173] = [__v_18, __v_19, __v_28]; 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_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_174] = { let __args: [G; IN_174] = [__v_28]; 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_52: G = __r_arr[0]; let __v_53: G = g_inverse_value(__v_52); let __v_54: G = (__v_52 * __v_53); @@ -16924,9 +17805,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_176] = { let __args: [G; IN_176] = [__v_28]; 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_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_174] = { let __args: [G; IN_174] = [__v_28]; 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_166: G = __r_arr[0]; let __v_167: G = (__v_165 * __v_166); let __v_168: G = g_inverse_value(__v_167); @@ -16945,7 +17826,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_183] = { let __args: [G; IN_183] = [__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[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_178: G = __r_arr[0]; let __v_179: G = __r_arr[1]; let __v_180: G = G::from_u64(0); @@ -17002,40 +17883,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_213] = { let __args: [G; IN_213] = [__v_41, __v_230]; 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_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_213] = { let __args: [G; IN_213] = [__v_39, __v_233]; 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_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_179] = { let __args: [G; IN_179] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __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_213] = { let __args: [G; IN_213] = [__v_41, __v_242]; 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_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_213] = { let __args: [G; IN_213] = [__v_39, __v_245]; 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_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_179] = { let __args: [G; IN_179] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __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_206] = { let __args: [G; IN_206] = [__v_25]; 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_231: G = __r_arr[0]; let __v_232: G = G::from_u64(0); let __v_233: G = G::from_u64(1); @@ -17046,7 +17927,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_186] = { let __args: [G; IN_186] = [__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[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_241: G = __r_arr[0]; let __v_242: G = __r_arr[1]; break '__mc_1 [__v_241, __v_242]; @@ -17058,19 +17939,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_204] = { let __args: [G; IN_204] = [__v_8, __v_9]; 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_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_204] = { let __args: [G; IN_204] = [__v_232, __v_233]; 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_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_181] = { let __args: [G; IN_181] = [__v_234]; 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_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_173] = { let __args: [G; IN_173] = [__v_18, __v_19, __v_28]; 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_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_189] = { let __args: [G; IN_189] = [__v_235, __v_236, __v_237, __v_238, __v_239]; 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_240: G = __r_arr[0]; let __v_241: G = __r_arr[1]; let __v_242: G = (__v_230 * __v_134); @@ -17087,7 +17968,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_206] = { let __args: [G; IN_206] = [__v_235]; 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_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 +17987,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_192] = { let __args: [G; IN_192] = [__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[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_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_192] = [__v_265]; + 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); }, } @@ -17121,15 +18002,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_193: usize = 3; +const IN_193: usize = 3; +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_181], 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]; @@ -17149,8 +18030,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_193] = [__v_13, __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); }, 0u64 => { @@ -17176,7 +18057,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_193] = { let __args: [G; IN_193] = [__v_0, __v_1, __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_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = (__v_0 * __v_35); @@ -17189,8 +18070,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_193] = [__v_45, __v_46]; + 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); }, _ => { @@ -17200,15 +18081,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_194: usize = 7; +const IN_194: usize = 7; +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_182], ExecError> { +) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -17223,12 +18104,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_194] = [__v_0, __v_1]; + 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); }, 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_193] = { let __args: [G; IN_193] = [__v_5, __v_6, __v_8]; 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_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = (__v_3 + __v_10); @@ -17258,11 +18139,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_194] = { let __args: [G; IN_194] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; 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_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_194] = [__v_33, __v_34]; + 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); }, _ => { @@ -17272,15 +18153,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_195: usize = 38; +const IN_195: usize = 38; +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_183], ExecError> { +) -> 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]; @@ -17319,24 +18200,25 @@ fn aiur_fn_183( let __v_34: G = inp[34]; let __v_35: G = inp[35]; let __v_36: G = inp[36]; + let __v_37: G = inp[37]; match __v_0.as_canonical_u64() { _ => { match __v_0.as_canonical_u64() { _ => { match __v_12.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; - let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_8, __v_12]; 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_38: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; match __v_13.as_canonical_u64() { _ => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() { 0u64 => { - let __v_39: G = G::from_u64(1); let __v_40: G = G::from_u64(1); - let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - break '__mc_0 [__v_41]; + let __v_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 } }; + break '__mc_0 [__v_42]; }, 1u64 => { break '__mc_0 [__v_10]; @@ -17346,522 +18228,557 @@ fn aiur_fn_183( }, } }; - let __v_39: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_17, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; - let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_17, __v_37]; 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_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_160] = { let __args: [G; IN_160] = [__v_13, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __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_160] = { let __args: [G; IN_160] = [__v_40, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __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_12, __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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_7, __v_44]; 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_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(109); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(117); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(108); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(116); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(105); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(45); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(115); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(116); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(97); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(114); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(107); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(47); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(118); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(48); + let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_70, __v_71, __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_68, __v_69, __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_66, __v_67, __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_64, __v_65, __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_62, __v_63, __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_60, __v_61, __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_58, __v_59, __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_56, __v_57, __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_54, __v_55, __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_52, __v_53, __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_50, __v_51, __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_48, __v_49, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_87: G = { let __values: [G; 3] = [__v_46, __v_47, __v_86]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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(1); - let __v_89: G = { let __values: [G; 3] = [__v_87, __v_88, __v_88]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_86, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_90: G = __r_arr[0]; - let __v_91: G = __r_arr[1]; - let __v_92: G = __r_arr[2]; - let __v_93: G = __r_arr[3]; - let __v_94: G = __r_arr[4]; - let __v_95: G = __r_arr[5]; - let __v_96: G = __r_arr[6]; - let __v_97: G = __r_arr[7]; - let __v_98: G = __r_arr[8]; - let __v_99: G = __r_arr[9]; - let __v_100: G = __r_arr[10]; - let __v_101: G = __r_arr[11]; - let __v_102: G = __r_arr[12]; - let __v_103: G = __r_arr[13]; - let __v_104: G = __r_arr[14]; - let __v_105: G = __r_arr[15]; - let __v_106: G = __r_arr[16]; - let __v_107: G = __r_arr[17]; - let __v_108: G = G::from_u64(1); + let __v_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_164] = { let __args: [G; IN_164] = [__v_87, __v_90]; 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_91: G = __r_arr[0]; + let __v_92: G = __r_arr[1]; + let __v_93: G = __r_arr[2]; + let __v_94: G = __r_arr[3]; + let __v_95: G = __r_arr[4]; + let __v_96: G = __r_arr[5]; + let __v_97: G = __r_arr[6]; + let __v_98: G = __r_arr[7]; + let __v_99: G = __r_arr[8]; + let __v_100: G = __r_arr[9]; + let __v_101: G = __r_arr[10]; + let __v_102: G = __r_arr[11]; + let __v_103: G = __r_arr[12]; + let __v_104: G = __r_arr[13]; + let __v_105: G = __r_arr[14]; + let __v_106: G = __r_arr[15]; + let __v_107: G = __r_arr[16]; + let __v_108: G = __r_arr[17]; let __v_109: G = G::from_u64(1); - let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; - let __v_111: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_110: G = G::from_u64(1); + let __v_111: G = { let __values: [G; 3] = [__v_109, __v_110, __v_110]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_111]; 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_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_158] = { let __args: [G; IN_158] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_112]; 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_113: G = __r_arr[0]; - let __v_114: G = G::from_u64(1); + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_107, __v_113]; 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_114: G = __r_arr[0]; let __v_115: G = G::from_u64(1); - let __v_116: G = { let __values: [G; 3] = [__v_114, __v_115, __v_115]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_113, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_117: G = __r_arr[0]; - let __v_118: G = __r_arr[1]; - let __v_119: G = __r_arr[2]; - let __v_120: G = __r_arr[3]; - let __v_121: G = __r_arr[4]; - let __v_122: G = __r_arr[5]; - let __v_123: G = __r_arr[6]; - let __v_124: G = __r_arr[7]; - let __v_125: G = __r_arr[8]; - let __v_126: G = __r_arr[9]; - let __v_127: G = __r_arr[10]; - let __v_128: G = __r_arr[11]; - let __v_129: G = __r_arr[12]; - let __v_130: G = __r_arr[13]; - let __v_131: G = __r_arr[14]; - let __v_132: G = __r_arr[15]; - let __v_133: G = __r_arr[16]; - let __v_134: G = __r_arr[17]; - let __v_135: G = G::from_u64(1); + let __v_116: G = G::from_u64(1); + let __v_117: G = { let __values: [G; 3] = [__v_115, __v_116, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_114, __v_117]; 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_118: G = __r_arr[0]; + let __v_119: G = __r_arr[1]; + let __v_120: G = __r_arr[2]; + let __v_121: G = __r_arr[3]; + let __v_122: G = __r_arr[4]; + let __v_123: G = __r_arr[5]; + let __v_124: G = __r_arr[6]; + let __v_125: G = __r_arr[7]; + let __v_126: G = __r_arr[8]; + let __v_127: G = __r_arr[9]; + let __v_128: G = __r_arr[10]; + let __v_129: G = __r_arr[11]; + let __v_130: G = __r_arr[12]; + let __v_131: G = __r_arr[13]; + let __v_132: G = __r_arr[14]; + let __v_133: G = __r_arr[15]; + let __v_134: G = __r_arr[16]; + let __v_135: G = __r_arr[17]; let __v_136: G = G::from_u64(1); - let __v_137: G = { let __values: [G; 3] = [__v_135, __v_136, __v_136]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_137]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; - let __v_138: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_138]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_137: G = G::from_u64(1); + let __v_138: G = { let __values: [G; 3] = [__v_136, __v_137, __v_137]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_138]; 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_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_158] = { let __args: [G; IN_158] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_139]; 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_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_207] = { let __args: [G; IN_207] = [__v_134, __v_140]; 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_141: G = __r_arr[0]; - let __v_142: G = G::from_u64(1); + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_141, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_142: G = __r_arr[0]; let __v_143: G = G::from_u64(1); - let __v_144: G = { let __values: [G; 3] = [__v_142, __v_143, __v_143]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_16, __v_144]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; - let __v_145: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_141, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_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_120] = { let __args: [G; IN_120] = [__v_16, __v_145]; 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_146: G = __r_arr[0]; - let __v_147: G = G::from_u64(1); + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_142, __v_146]; 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_147: G = __r_arr[0]; let __v_148: G = G::from_u64(1); - let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_146, __v_149]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_150: G = __r_arr[0]; - let __v_151: G = __r_arr[1]; - let __v_152: G = __r_arr[2]; - let __v_153: G = __r_arr[3]; - let __v_154: G = __r_arr[4]; - let __v_155: G = __r_arr[5]; - let __v_156: G = __r_arr[6]; - let __v_157: G = __r_arr[7]; - let __v_158: G = __r_arr[8]; - let __v_159: G = __r_arr[9]; - let __v_160: G = __r_arr[10]; - let __v_161: G = __r_arr[11]; - let __v_162: G = __r_arr[12]; - let __v_163: G = __r_arr[13]; - let __v_164: G = __r_arr[14]; - let __v_165: G = __r_arr[15]; - let __v_166: G = __r_arr[16]; - let __v_167: G = __r_arr[17]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_166, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; - let __v_168: G = __r_arr[0]; - let __v_169: G = G::from_u64(1); + let __v_149: G = G::from_u64(1); + let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_147, __v_150]; 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_151: G = __r_arr[0]; + let __v_152: G = __r_arr[1]; + let __v_153: G = __r_arr[2]; + let __v_154: G = __r_arr[3]; + let __v_155: G = __r_arr[4]; + let __v_156: G = __r_arr[5]; + let __v_157: G = __r_arr[6]; + let __v_158: G = __r_arr[7]; + let __v_159: G = __r_arr[8]; + let __v_160: G = __r_arr[9]; + let __v_161: G = __r_arr[10]; + let __v_162: G = __r_arr[11]; + let __v_163: G = __r_arr[12]; + let __v_164: G = __r_arr[13]; + let __v_165: G = __r_arr[14]; + let __v_166: G = __r_arr[15]; + let __v_167: G = __r_arr[16]; + let __v_168: G = __r_arr[17]; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_167, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_169: G = __r_arr[0]; let __v_170: G = G::from_u64(1); - let __v_171: G = { let __values: [G; 3] = [__v_169, __v_170, __v_170]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_168, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_172: G = __r_arr[0]; - let __v_173: G = __r_arr[1]; - let __v_174: G = __r_arr[2]; - let __v_175: G = __r_arr[3]; - let __v_176: G = __r_arr[4]; - let __v_177: G = __r_arr[5]; - let __v_178: G = __r_arr[6]; - let __v_179: G = __r_arr[7]; - let __v_180: G = __r_arr[8]; - let __v_181: G = __r_arr[9]; - let __v_182: G = __r_arr[10]; - let __v_183: G = __r_arr[11]; - let __v_184: G = __r_arr[12]; - let __v_185: G = __r_arr[13]; - let __v_186: G = __r_arr[14]; - let __v_187: G = __r_arr[15]; - let __v_188: G = __r_arr[16]; - let __v_189: G = __r_arr[17]; - let __v_190: G = G::from_u64(256); - let __v_191: G = (__v_190 * __v_91); - let __v_192: G = G::from_u64(65536); - let __v_193: G = (__v_192 * __v_92); - let __v_194: G = G::from_u64(16777216); - let __v_195: G = (__v_194 * __v_93); - let __v_196: G = G::from_u64(4294967296); - let __v_197: G = (__v_196 * __v_94); - let __v_198: G = G::from_u64(1099511627776); - let __v_199: G = (__v_198 * __v_95); - let __v_200: G = G::from_u64(281474976710656); - let __v_201: G = (__v_200 * __v_96); - let __v_202: G = G::from_u64(72057594037927936); - let __v_203: G = (__v_202 * __v_97); - let __v_204: G = (__v_201 + __v_203); - let __v_205: G = (__v_199 + __v_204); - let __v_206: G = (__v_197 + __v_205); - let __v_207: G = (__v_195 + __v_206); - let __v_208: G = (__v_193 + __v_207); - let __v_209: G = (__v_191 + __v_208); - let __v_210: G = (__v_90 + __v_209); - let __v_211: G = G::from_u64(256); - let __v_212: G = (__v_211 * __v_99); - let __v_213: G = G::from_u64(65536); - let __v_214: G = (__v_213 * __v_100); - let __v_215: G = G::from_u64(16777216); - let __v_216: G = (__v_215 * __v_101); - let __v_217: G = G::from_u64(4294967296); - let __v_218: G = (__v_217 * __v_102); - let __v_219: G = G::from_u64(1099511627776); - let __v_220: G = (__v_219 * __v_103); - let __v_221: G = G::from_u64(281474976710656); - let __v_222: G = (__v_221 * __v_104); - let __v_223: G = G::from_u64(72057594037927936); - let __v_224: G = (__v_223 * __v_105); - let __v_225: G = (__v_222 + __v_224); - let __v_226: G = (__v_220 + __v_225); - let __v_227: G = (__v_218 + __v_226); - let __v_228: G = (__v_216 + __v_227); - let __v_229: G = (__v_214 + __v_228); - let __v_230: G = (__v_212 + __v_229); - let __v_231: G = (__v_98 + __v_230); - let __v_232: G = G::from_u64(256); - let __v_233: G = (__v_232 * __v_118); - let __v_234: G = G::from_u64(65536); - let __v_235: G = (__v_234 * __v_119); - let __v_236: G = G::from_u64(16777216); - let __v_237: G = (__v_236 * __v_120); - let __v_238: G = G::from_u64(4294967296); - let __v_239: G = (__v_238 * __v_121); - let __v_240: G = G::from_u64(1099511627776); - let __v_241: G = (__v_240 * __v_122); - let __v_242: G = G::from_u64(281474976710656); - let __v_243: G = (__v_242 * __v_123); - let __v_244: G = G::from_u64(72057594037927936); - let __v_245: G = (__v_244 * __v_124); - let __v_246: G = (__v_243 + __v_245); - let __v_247: G = (__v_241 + __v_246); - let __v_248: G = (__v_239 + __v_247); - let __v_249: G = (__v_237 + __v_248); - let __v_250: G = (__v_235 + __v_249); - let __v_251: G = (__v_233 + __v_250); - let __v_252: G = (__v_117 + __v_251); - let __v_253: G = G::from_u64(256); - let __v_254: G = (__v_253 * __v_126); - let __v_255: G = G::from_u64(65536); - let __v_256: G = (__v_255 * __v_127); - let __v_257: G = G::from_u64(16777216); - let __v_258: G = (__v_257 * __v_128); - let __v_259: G = G::from_u64(4294967296); - let __v_260: G = (__v_259 * __v_129); - let __v_261: G = G::from_u64(1099511627776); - let __v_262: G = (__v_261 * __v_130); - let __v_263: G = G::from_u64(281474976710656); - let __v_264: G = (__v_263 * __v_131); - let __v_265: G = G::from_u64(72057594037927936); - let __v_266: G = (__v_265 * __v_132); - let __v_267: G = (__v_264 + __v_266); - let __v_268: G = (__v_262 + __v_267); - let __v_269: G = (__v_260 + __v_268); - let __v_270: G = (__v_258 + __v_269); - let __v_271: G = (__v_256 + __v_270); - let __v_272: G = (__v_254 + __v_271); - let __v_273: G = (__v_125 + __v_272); - let __v_274: G = G::from_u64(256); - let __v_275: G = (__v_274 * __v_151); - let __v_276: G = G::from_u64(65536); - let __v_277: G = (__v_276 * __v_152); - let __v_278: G = G::from_u64(16777216); - let __v_279: G = (__v_278 * __v_153); - let __v_280: G = G::from_u64(4294967296); - let __v_281: G = (__v_280 * __v_154); - let __v_282: G = G::from_u64(1099511627776); - let __v_283: G = (__v_282 * __v_155); - let __v_284: G = G::from_u64(281474976710656); - let __v_285: G = (__v_284 * __v_156); - let __v_286: G = G::from_u64(72057594037927936); - let __v_287: G = (__v_286 * __v_157); - let __v_288: G = (__v_285 + __v_287); - let __v_289: G = (__v_283 + __v_288); - let __v_290: G = (__v_281 + __v_289); - let __v_291: G = (__v_279 + __v_290); - let __v_292: G = (__v_277 + __v_291); - let __v_293: G = (__v_275 + __v_292); - let __v_294: G = (__v_150 + __v_293); - let __v_295: G = G::from_u64(256); - let __v_296: G = (__v_295 * __v_159); - let __v_297: G = G::from_u64(65536); - let __v_298: G = (__v_297 * __v_160); - let __v_299: G = G::from_u64(16777216); - let __v_300: G = (__v_299 * __v_161); - let __v_301: G = G::from_u64(4294967296); - let __v_302: G = (__v_301 * __v_162); - let __v_303: G = G::from_u64(1099511627776); - let __v_304: G = (__v_303 * __v_163); - let __v_305: G = G::from_u64(281474976710656); - let __v_306: G = (__v_305 * __v_164); - let __v_307: G = G::from_u64(72057594037927936); - let __v_308: G = (__v_307 * __v_165); - let __v_309: G = (__v_306 + __v_308); - let __v_310: G = (__v_304 + __v_309); - let __v_311: G = (__v_302 + __v_310); - let __v_312: G = (__v_300 + __v_311); - let __v_313: G = (__v_298 + __v_312); - let __v_314: G = (__v_296 + __v_313); - let __v_315: G = (__v_158 + __v_314); - let __v_316: G = G::from_u64(256); - let __v_317: G = (__v_316 * __v_173); - let __v_318: G = G::from_u64(65536); - let __v_319: G = (__v_318 * __v_174); - let __v_320: G = G::from_u64(16777216); - let __v_321: G = (__v_320 * __v_175); - let __v_322: G = G::from_u64(4294967296); - let __v_323: G = (__v_322 * __v_176); - let __v_324: G = G::from_u64(1099511627776); - let __v_325: G = (__v_324 * __v_177); - let __v_326: G = G::from_u64(281474976710656); - let __v_327: G = (__v_326 * __v_178); - let __v_328: G = G::from_u64(72057594037927936); - let __v_329: G = (__v_328 * __v_179); - let __v_330: G = (__v_327 + __v_329); - let __v_331: G = (__v_325 + __v_330); - let __v_332: G = (__v_323 + __v_331); - let __v_333: G = (__v_321 + __v_332); - let __v_334: G = (__v_319 + __v_333); - let __v_335: G = (__v_317 + __v_334); - let __v_336: G = (__v_172 + __v_335); - let __v_337: G = G::from_u64(256); - let __v_338: G = (__v_337 * __v_181); - let __v_339: G = G::from_u64(65536); - let __v_340: G = (__v_339 * __v_182); - let __v_341: G = G::from_u64(16777216); - let __v_342: G = (__v_341 * __v_183); - let __v_343: G = G::from_u64(4294967296); - let __v_344: G = (__v_343 * __v_184); - let __v_345: G = G::from_u64(1099511627776); - let __v_346: G = (__v_345 * __v_185); - let __v_347: G = G::from_u64(281474976710656); - let __v_348: G = (__v_347 * __v_186); - let __v_349: G = G::from_u64(72057594037927936); - let __v_350: G = (__v_349 * __v_187); - let __v_351: G = (__v_348 + __v_350); - let __v_352: G = (__v_346 + __v_351); - let __v_353: G = (__v_344 + __v_352); - let __v_354: G = (__v_342 + __v_353); - let __v_355: G = (__v_340 + __v_354); - let __v_356: G = (__v_338 + __v_355); - let __v_357: G = (__v_180 + __v_356); - let __v_358: G = G::from_u64(0); + let __v_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_164] = { let __args: [G; IN_164] = [__v_169, __v_172]; 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_173: G = __r_arr[0]; + let __v_174: G = __r_arr[1]; + let __v_175: G = __r_arr[2]; + let __v_176: G = __r_arr[3]; + let __v_177: G = __r_arr[4]; + let __v_178: G = __r_arr[5]; + let __v_179: G = __r_arr[6]; + let __v_180: G = __r_arr[7]; + let __v_181: G = __r_arr[8]; + let __v_182: G = __r_arr[9]; + let __v_183: G = __r_arr[10]; + let __v_184: G = __r_arr[11]; + let __v_185: G = __r_arr[12]; + let __v_186: G = __r_arr[13]; + let __v_187: G = __r_arr[14]; + let __v_188: G = __r_arr[15]; + let __v_189: G = __r_arr[16]; + let __v_190: G = __r_arr[17]; + let __v_191: G = G::from_u64(256); + let __v_192: G = (__v_191 * __v_92); + let __v_193: G = G::from_u64(65536); + let __v_194: G = (__v_193 * __v_93); + let __v_195: G = G::from_u64(16777216); + let __v_196: G = (__v_195 * __v_94); + let __v_197: G = G::from_u64(4294967296); + let __v_198: G = (__v_197 * __v_95); + let __v_199: G = G::from_u64(1099511627776); + let __v_200: G = (__v_199 * __v_96); + let __v_201: G = G::from_u64(281474976710656); + let __v_202: G = (__v_201 * __v_97); + let __v_203: G = G::from_u64(72057594037927936); + let __v_204: G = (__v_203 * __v_98); + let __v_205: G = (__v_202 + __v_204); + let __v_206: G = (__v_200 + __v_205); + let __v_207: G = (__v_198 + __v_206); + let __v_208: G = (__v_196 + __v_207); + let __v_209: G = (__v_194 + __v_208); + let __v_210: G = (__v_192 + __v_209); + let __v_211: G = (__v_91 + __v_210); + let __v_212: G = G::from_u64(256); + let __v_213: G = (__v_212 * __v_100); + let __v_214: G = G::from_u64(65536); + let __v_215: G = (__v_214 * __v_101); + let __v_216: G = G::from_u64(16777216); + let __v_217: G = (__v_216 * __v_102); + let __v_218: G = G::from_u64(4294967296); + let __v_219: G = (__v_218 * __v_103); + let __v_220: G = G::from_u64(1099511627776); + let __v_221: G = (__v_220 * __v_104); + let __v_222: G = G::from_u64(281474976710656); + let __v_223: G = (__v_222 * __v_105); + let __v_224: G = G::from_u64(72057594037927936); + let __v_225: G = (__v_224 * __v_106); + let __v_226: G = (__v_223 + __v_225); + let __v_227: G = (__v_221 + __v_226); + let __v_228: G = (__v_219 + __v_227); + let __v_229: G = (__v_217 + __v_228); + let __v_230: G = (__v_215 + __v_229); + let __v_231: G = (__v_213 + __v_230); + let __v_232: G = (__v_99 + __v_231); + let __v_233: G = G::from_u64(256); + let __v_234: G = (__v_233 * __v_119); + let __v_235: G = G::from_u64(65536); + let __v_236: G = (__v_235 * __v_120); + let __v_237: G = G::from_u64(16777216); + let __v_238: G = (__v_237 * __v_121); + let __v_239: G = G::from_u64(4294967296); + let __v_240: G = (__v_239 * __v_122); + let __v_241: G = G::from_u64(1099511627776); + let __v_242: G = (__v_241 * __v_123); + let __v_243: G = G::from_u64(281474976710656); + let __v_244: G = (__v_243 * __v_124); + let __v_245: G = G::from_u64(72057594037927936); + let __v_246: G = (__v_245 * __v_125); + let __v_247: G = (__v_244 + __v_246); + let __v_248: G = (__v_242 + __v_247); + let __v_249: G = (__v_240 + __v_248); + let __v_250: G = (__v_238 + __v_249); + let __v_251: G = (__v_236 + __v_250); + let __v_252: G = (__v_234 + __v_251); + let __v_253: G = (__v_118 + __v_252); + let __v_254: G = G::from_u64(256); + let __v_255: G = (__v_254 * __v_127); + let __v_256: G = G::from_u64(65536); + let __v_257: G = (__v_256 * __v_128); + let __v_258: G = G::from_u64(16777216); + let __v_259: G = (__v_258 * __v_129); + let __v_260: G = G::from_u64(4294967296); + let __v_261: G = (__v_260 * __v_130); + let __v_262: G = G::from_u64(1099511627776); + let __v_263: G = (__v_262 * __v_131); + let __v_264: G = G::from_u64(281474976710656); + let __v_265: G = (__v_264 * __v_132); + let __v_266: G = G::from_u64(72057594037927936); + let __v_267: G = (__v_266 * __v_133); + let __v_268: G = (__v_265 + __v_267); + let __v_269: G = (__v_263 + __v_268); + let __v_270: G = (__v_261 + __v_269); + let __v_271: G = (__v_259 + __v_270); + let __v_272: G = (__v_257 + __v_271); + let __v_273: G = (__v_255 + __v_272); + let __v_274: G = (__v_126 + __v_273); + let __v_275: G = G::from_u64(256); + let __v_276: G = (__v_275 * __v_152); + let __v_277: G = G::from_u64(65536); + let __v_278: G = (__v_277 * __v_153); + let __v_279: G = G::from_u64(16777216); + let __v_280: G = (__v_279 * __v_154); + let __v_281: G = G::from_u64(4294967296); + let __v_282: G = (__v_281 * __v_155); + let __v_283: G = G::from_u64(1099511627776); + let __v_284: G = (__v_283 * __v_156); + let __v_285: G = G::from_u64(281474976710656); + let __v_286: G = (__v_285 * __v_157); + let __v_287: G = G::from_u64(72057594037927936); + let __v_288: G = (__v_287 * __v_158); + let __v_289: G = (__v_286 + __v_288); + let __v_290: G = (__v_284 + __v_289); + let __v_291: G = (__v_282 + __v_290); + let __v_292: G = (__v_280 + __v_291); + let __v_293: G = (__v_278 + __v_292); + let __v_294: G = (__v_276 + __v_293); + let __v_295: G = (__v_151 + __v_294); + let __v_296: G = G::from_u64(256); + let __v_297: G = (__v_296 * __v_160); + let __v_298: G = G::from_u64(65536); + let __v_299: G = (__v_298 * __v_161); + let __v_300: G = G::from_u64(16777216); + let __v_301: G = (__v_300 * __v_162); + let __v_302: G = G::from_u64(4294967296); + let __v_303: G = (__v_302 * __v_163); + let __v_304: G = G::from_u64(1099511627776); + let __v_305: G = (__v_304 * __v_164); + let __v_306: G = G::from_u64(281474976710656); + let __v_307: G = (__v_306 * __v_165); + let __v_308: G = G::from_u64(72057594037927936); + let __v_309: G = (__v_308 * __v_166); + let __v_310: G = (__v_307 + __v_309); + let __v_311: G = (__v_305 + __v_310); + let __v_312: G = (__v_303 + __v_311); + let __v_313: G = (__v_301 + __v_312); + let __v_314: G = (__v_299 + __v_313); + let __v_315: G = (__v_297 + __v_314); + let __v_316: G = (__v_159 + __v_315); + let __v_317: G = G::from_u64(256); + let __v_318: G = (__v_317 * __v_174); + let __v_319: G = G::from_u64(65536); + let __v_320: G = (__v_319 * __v_175); + let __v_321: G = G::from_u64(16777216); + let __v_322: G = (__v_321 * __v_176); + let __v_323: G = G::from_u64(4294967296); + let __v_324: G = (__v_323 * __v_177); + let __v_325: G = G::from_u64(1099511627776); + let __v_326: G = (__v_325 * __v_178); + let __v_327: G = G::from_u64(281474976710656); + let __v_328: G = (__v_327 * __v_179); + let __v_329: G = G::from_u64(72057594037927936); + let __v_330: G = (__v_329 * __v_180); + let __v_331: G = (__v_328 + __v_330); + let __v_332: G = (__v_326 + __v_331); + let __v_333: G = (__v_324 + __v_332); + let __v_334: G = (__v_322 + __v_333); + let __v_335: G = (__v_320 + __v_334); + let __v_336: G = (__v_318 + __v_335); + let __v_337: G = (__v_173 + __v_336); + let __v_338: G = G::from_u64(256); + let __v_339: G = (__v_338 * __v_182); + let __v_340: G = G::from_u64(65536); + let __v_341: G = (__v_340 * __v_183); + let __v_342: G = G::from_u64(16777216); + let __v_343: G = (__v_342 * __v_184); + let __v_344: G = G::from_u64(4294967296); + let __v_345: G = (__v_344 * __v_185); + let __v_346: G = G::from_u64(1099511627776); + let __v_347: G = (__v_346 * __v_186); + let __v_348: G = G::from_u64(281474976710656); + let __v_349: G = (__v_348 * __v_187); + let __v_350: G = G::from_u64(72057594037927936); + let __v_351: G = (__v_350 * __v_188); + let __v_352: G = (__v_349 + __v_351); + let __v_353: G = (__v_347 + __v_352); + let __v_354: G = (__v_345 + __v_353); + let __v_355: G = (__v_343 + __v_354); + let __v_356: G = (__v_341 + __v_355); + let __v_357: G = (__v_339 + __v_356); + let __v_358: G = (__v_181 + __v_357); let __v_359: G = G::from_u64(0); - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_358, __v_359, __v_35, __v_210, __v_231, __v_252, __v_273]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; - let __v_360: G = __r_arr[0]; - let __v_361: G = __r_arr[1]; - let __v_362: G = G::from_u64(0); - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_37, __v_38, __v_17, __v_16, __v_33, __v_34, __v_31, __v_32, __v_30, __v_362, __v_360, __v_361, __v_210, __v_231, __v_252, __v_273, __v_294, __v_315, __v_336, __v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; - let __v_363: G = __r_arr[0]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __v_360: G = G::from_u64(0); + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_359, __v_360, __v_36, __v_211, __v_232, __v_253, __v_274]; 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_361: G = __r_arr[0]; + let __v_362: G = __r_arr[1]; + let __v_363: G = G::from_u64(0); + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_38, __v_39, __v_17, __v_16, __v_34, __v_35, __v_32, __v_33, __v_31, __v_363, __v_361, __v_362, __v_211, __v_232, __v_253, __v_274, __v_295, __v_316, __v_337, __v_358]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_364: G = __r_arr[0]; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_38]; 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_365: G = __r_arr[0]; match __v_18.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_365: G = __r_arr[0]; - let __v_366: G = G::from_u64(1); + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_18]; 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_366: G = __r_arr[0]; let __v_367: G = G::from_u64(1); - let __v_368: G = { let __values: [G; 3] = [__v_366, __v_367, __v_367]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_31.as_canonical_u64() { + let __v_368: G = G::from_u64(1); + let __v_369: G = { let __values: [G; 3] = [__v_367, __v_368, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_32.as_canonical_u64() { 0u64 => { - break '__mc_1 [__v_368]; + break '__mc_1 [__v_369]; }, 1u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_32, __v_368]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_369: G = __r_arr[0]; - break '__mc_1 [__v_369]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_33, __v_369]; 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_370: G = __r_arr[0]; + break '__mc_1 [__v_370]; }, _ => { - return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64())); }, } }; - let __v_369: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_30, __v_369]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_370: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_34, __v_370]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_370: G = __mc_out___mc_1[0]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_31, __v_370]; 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_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_122] = { let __args: [G; IN_122] = [__v_35, __v_371]; 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_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_122] = { let __args: [G; IN_122] = [__v_34, __v_372]; 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_373: G = __r_arr[0]; - let __v_374: G = G::from_u64(1); + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_189, __v_373]; 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_374: G = __r_arr[0]; let __v_375: G = G::from_u64(1); - let __v_376: G = { let __values: [G; 3] = [__v_374, __v_375, __v_375]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_373, __v_376]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_377: G = __r_arr[0]; - let __v_378: G = __r_arr[1]; - let __v_379: G = __r_arr[2]; - let __v_380: G = __r_arr[3]; - let __v_381: G = __r_arr[4]; - let __v_382: G = __r_arr[5]; - let __v_383: G = __r_arr[6]; - let __v_384: G = __r_arr[7]; - let __v_385: G = __r_arr[8]; - let __v_386: G = __r_arr[9]; - let __v_387: G = __r_arr[10]; - let __v_388: G = __r_arr[11]; - let __v_389: G = __r_arr[12]; - let __v_390: G = __r_arr[13]; - let __v_391: G = __r_arr[14]; - let __v_392: G = __r_arr[15]; - let __v_393: G = __r_arr[16]; - let __v_394: G = __r_arr[17]; - let __v_395: G = G::from_u64(256); - let __v_396: G = (__v_395 * __v_378); - let __v_397: G = G::from_u64(65536); - let __v_398: G = (__v_397 * __v_379); - let __v_399: G = G::from_u64(16777216); - let __v_400: G = (__v_399 * __v_380); - let __v_401: G = G::from_u64(4294967296); - let __v_402: G = (__v_401 * __v_381); - let __v_403: G = G::from_u64(1099511627776); - let __v_404: G = (__v_403 * __v_382); - let __v_405: G = G::from_u64(281474976710656); - let __v_406: G = (__v_405 * __v_383); - let __v_407: G = G::from_u64(72057594037927936); - let __v_408: G = (__v_407 * __v_384); - let __v_409: G = (__v_406 + __v_408); - let __v_410: G = (__v_404 + __v_409); - let __v_411: G = (__v_402 + __v_410); - let __v_412: G = (__v_400 + __v_411); - let __v_413: G = (__v_398 + __v_412); - let __v_414: G = (__v_396 + __v_413); - let __v_415: G = (__v_377 + __v_414); - let __v_416: G = G::from_u64(256); - let __v_417: G = (__v_416 * __v_386); - let __v_418: G = G::from_u64(65536); - let __v_419: G = (__v_418 * __v_387); - let __v_420: G = G::from_u64(16777216); - let __v_421: G = (__v_420 * __v_388); - let __v_422: G = G::from_u64(4294967296); - let __v_423: G = (__v_422 * __v_389); - let __v_424: G = G::from_u64(1099511627776); - let __v_425: G = (__v_424 * __v_390); - let __v_426: G = G::from_u64(281474976710656); - let __v_427: G = (__v_426 * __v_391); - let __v_428: G = G::from_u64(72057594037927936); - let __v_429: G = (__v_428 * __v_392); - let __v_430: G = (__v_427 + __v_429); - let __v_431: G = (__v_425 + __v_430); - let __v_432: G = (__v_423 + __v_431); - let __v_433: G = (__v_421 + __v_432); - let __v_434: G = (__v_419 + __v_433); - let __v_435: G = (__v_417 + __v_434); - let __v_436: G = (__v_385 + __v_435); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_393, __v_18, __v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; - let __v_437: G = __r_arr[0]; - let __v_438: G = __r_arr[1]; - let __v_439: G = G::from_u64(1); + let __v_376: G = G::from_u64(1); + let __v_377: G = { let __values: [G; 3] = [__v_375, __v_376, __v_376]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_374, __v_377]; 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_378: G = __r_arr[0]; + let __v_379: G = __r_arr[1]; + let __v_380: G = __r_arr[2]; + let __v_381: G = __r_arr[3]; + let __v_382: G = __r_arr[4]; + let __v_383: G = __r_arr[5]; + let __v_384: G = __r_arr[6]; + let __v_385: G = __r_arr[7]; + let __v_386: G = __r_arr[8]; + let __v_387: G = __r_arr[9]; + let __v_388: G = __r_arr[10]; + let __v_389: G = __r_arr[11]; + let __v_390: G = __r_arr[12]; + let __v_391: G = __r_arr[13]; + let __v_392: G = __r_arr[14]; + let __v_393: G = __r_arr[15]; + let __v_394: G = __r_arr[16]; + let __v_395: G = __r_arr[17]; + let __v_396: G = G::from_u64(256); + let __v_397: G = (__v_396 * __v_379); + let __v_398: G = G::from_u64(65536); + let __v_399: G = (__v_398 * __v_380); + let __v_400: G = G::from_u64(16777216); + let __v_401: G = (__v_400 * __v_381); + let __v_402: G = G::from_u64(4294967296); + let __v_403: G = (__v_402 * __v_382); + let __v_404: G = G::from_u64(1099511627776); + let __v_405: G = (__v_404 * __v_383); + let __v_406: G = G::from_u64(281474976710656); + let __v_407: G = (__v_406 * __v_384); + let __v_408: G = G::from_u64(72057594037927936); + let __v_409: G = (__v_408 * __v_385); + let __v_410: G = (__v_407 + __v_409); + let __v_411: G = (__v_405 + __v_410); + let __v_412: G = (__v_403 + __v_411); + let __v_413: G = (__v_401 + __v_412); + let __v_414: G = (__v_399 + __v_413); + let __v_415: G = (__v_397 + __v_414); + let __v_416: G = (__v_378 + __v_415); + let __v_417: G = G::from_u64(256); + let __v_418: G = (__v_417 * __v_387); + let __v_419: G = G::from_u64(65536); + let __v_420: G = (__v_419 * __v_388); + let __v_421: G = G::from_u64(16777216); + let __v_422: G = (__v_421 * __v_389); + let __v_423: G = G::from_u64(4294967296); + let __v_424: G = (__v_423 * __v_390); + let __v_425: G = G::from_u64(1099511627776); + let __v_426: G = (__v_425 * __v_391); + let __v_427: G = G::from_u64(281474976710656); + let __v_428: G = (__v_427 * __v_392); + let __v_429: G = G::from_u64(72057594037927936); + let __v_430: G = (__v_429 * __v_393); + let __v_431: G = (__v_428 + __v_430); + let __v_432: G = (__v_426 + __v_431); + let __v_433: G = (__v_424 + __v_432); + let __v_434: G = (__v_422 + __v_433); + let __v_435: G = (__v_420 + __v_434); + let __v_436: G = (__v_418 + __v_435); + let __v_437: G = (__v_386 + __v_436); + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_394, __v_18, __v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __v_438: G = __r_arr[0]; + let __v_439: G = __r_arr[1]; let __v_440: G = G::from_u64(1); - let __v_441: G = { let __values: [G; 3] = [__v_439, __v_440, __v_440]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_21, __v_441]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; - let __v_442: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_438, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_441: G = G::from_u64(1); + let __v_442: G = { let __values: [G; 3] = [__v_440, __v_441, __v_441]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_22, __v_442]; 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_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_207] = { let __args: [G; IN_207] = [__v_439, __v_443]; 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_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_18]; 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 __v_448: G = __r_arr[0]; - let __v_449: G = G::from_u64(1); - if (__v_448 != __v_449) { - return Err(ExecError::AssertEqMismatch { lhs: __v_448.as_canonical_u64(), rhs: __v_449.as_canonical_u64(), msg: None }); - } - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_450: G = __r_arr[0]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_445, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_6]; 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_446: G = __r_arr[0]; + let __v_447: G = __r_arr[1]; + let __v_448: G = (__v_366 + __v_0); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_446, __v_447, __v_4, __v_448]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_449: G = __r_arr[0]; + let __v_450: G = G::from_u64(0); + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_20, __v_21, __v_450, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_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_146] = { let __args: [G; IN_146] = [__v_446, __v_447, __v_451, __v_416, __v_437, __v_34, __v_35, __v_31, __v_32, __v_33, __v_13, __v_14, __v_15, __v_40, __v_39, __v_17, __v_337, __v_358, __v_365, __v_0, __v_448, __v_438, __v_18, __v_22, __v_366]; let __cu = unconstrained; 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_452: G = __r_arr[0]; + let __v_453: G = G::from_u64(0); + if (__v_1 != __v_453) { + return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_453.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_455: G = __r_arr[0]; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __v_454: G = G::from_u64(0); + if (__v_2 != __v_454) { + return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: None }); + } + let __v_455: G = G::from_u64(1); + if (__v_3 != __v_455) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_456: G = __r_arr[0]; - let __v_457: G = (__v_455 - __v_456); - let __v_458: G = G::from_bool((__v_457 == G::ZERO)); - let __v_459: G = G::from_u64(1); - if (__v_458 != __v_459) { - return Err(ExecError::AssertEqMismatch { lhs: __v_458.as_canonical_u64(), rhs: __v_459.as_canonical_u64(), msg: None }); + let __v_457: G = G::from_u64(1); + if (__v_456 != __v_457) { + return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_457.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_460: G = __r_arr[0]; - let __v_461: G = (__v_460 - __v_365); - let __v_462: G = G::from_bool((__v_461 == G::ZERO)); - let __v_463: G = G::from_u64(1); - if (__v_462 != __v_463) { - return Err(ExecError::AssertEqMismatch { lhs: __v_462.as_canonical_u64(), rhs: __v_463.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_12]; 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_458: G = __r_arr[0]; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_8]; 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_459: G = __r_arr[0]; + let __v_460: G = (__v_458 - __v_459); + let __v_461: G = G::from_bool((__v_460 == G::ZERO)); + let __v_462: G = G::from_u64(1); + if (__v_461 != __v_462) { + return Err(ExecError::AssertEqMismatch { lhs: __v_461.as_canonical_u64(), rhs: __v_462.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_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_217] = { let __args: [G; IN_217] = [__v_38]; 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_463: G = __r_arr[0]; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_16]; 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_464: G = __r_arr[0]; - let __v_465: G = (__v_464 - __v_4); + let __v_465: G = (__v_463 - __v_464); let __v_466: G = G::from_bool((__v_465 == G::ZERO)); let __v_467: G = G::from_u64(1); if (__v_466 != __v_467) { return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_467.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_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_210] = { let __args: [G; IN_210] = [__v_19]; 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 __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_469: G = (__v_468 - __v_366); + let __v_470: G = G::from_bool((__v_469 == G::ZERO)); + let __v_471: G = G::from_u64(1); + if (__v_470 != __v_471) { + return Err(ExecError::AssertEqMismatch { lhs: __v_470.as_canonical_u64(), rhs: __v_471.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_20]; 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_472: G = __r_arr[0]; + let __v_473: G = G::from_u64(3); + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_32, __v_33]; 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_474: G = __r_arr[0]; + let __v_475: G = (__v_473 + __v_474); + if (__v_472 != __v_475) { + return Err(ExecError::AssertEqMismatch { lhs: __v_472.as_canonical_u64(), rhs: __v_475.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_21]; 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_476: G = __r_arr[0]; + let __v_477: G = (__v_476 - __v_366); + let __v_478: G = G::from_bool((__v_477 == G::ZERO)); + let __v_479: G = G::from_u64(1); + if (__v_478 != __v_479) { + return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: None }); } - let __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_206] = { let __args: [G; IN_206] = [__v_22]; 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_480: G = __r_arr[0]; + let __v_481: G = G::from_u64(1); + if (__v_480 != __v_481) { + return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_481.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_445, __v_446, __v_20, __v_415, __v_436, __v_33, __v_34, __v_30, __v_31, __v_32, __v_13, __v_14, __v_15, __v_39, __v_38, __v_17, __v_336, __v_357, __v_364, __v_0, __v_447, __v_437, __v_18, __v_21, __v_365]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; - let __v_473: G = __r_arr[0]; - let __ret: [G; OUT_183] = [__v_473]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_482: G = G::from_u64(33); + let __v_483: G = { let __a_val = __v_448.as_canonical_u64(); let __b_val = __v_482.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_484: G = G::from_u64(1); + if (__v_483 != __v_484) { + return Err(ExecError::AssertEqMismatch { lhs: __v_483.as_canonical_u64(), rhs: __v_484.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_20, __v_449, __v_13, __v_14, __v_15, __v_40, __v_32, __v_33, __v_39, __v_17, __v_365, __v_0, __v_448]; let __cu = unconstrained; 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_485: G = __r_arr[0]; + let __v_486: G = G::from_u64(1); + if (__v_485 != __v_486) { + return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_486.as_canonical_u64(), msg: None }); + } + let __v_487: G = G::from_u64(0); + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_21, __v_18, __v_452, __v_449, __v_487, __v_448]; 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_488: G = __r_arr[0]; + let __ret: [G; OUT_195] = [__v_488]; + 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); }, } @@ -17876,15 +18793,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_196: usize = 1; +const IN_196: usize = 1; +const OUT_196: usize = 1; +fn aiur_fn_196( + inp: [G; IN_196], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_184], ExecError> { +) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -17894,8 +18811,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_196] = [__v_4]; + 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); }, 0u64 => { @@ -17906,10 +18823,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_196] = { let __args: [G; IN_196] = [__v_3]; 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_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_196] = [__v_8]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -17919,15 +18836,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_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_185], ExecError> { +) -> 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]; @@ -17945,8 +18862,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_197] = [__v_12]; + 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); }, 0u64 => { @@ -17958,19 +18875,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_197] = { let __args: [G; IN_197] = [__v_9, __v_12]; 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_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_197] = [__v_13]; + 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); }, _ => { 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_197] = { let __args: [G; IN_197] = [__v_9, __v_12]; 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_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_197] = [__v_15]; + 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); }, } @@ -17987,15 +18904,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_198: usize = 2; +const IN_198: usize = 2; +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_186], ExecError> { +) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18009,8 +18926,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_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); }, 0u64 => { @@ -18022,19 +18939,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_198] = { let __args: [G; IN_198] = [__v_5, __v_8]; 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_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_198] = [__v_9]; + 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); }, _ => { 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_198] = { let __args: [G; IN_198] = [__v_5, __v_8]; 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_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_198] = [__v_11]; + 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); }, } @@ -18051,38 +18968,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_199: usize = 1; +const IN_199: usize = 1; +const OUT_199: usize = 2; +fn aiur_fn_199( + inp: [G; IN_199], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_187], ExecError> { +) -> Result<[G; OUT_199], 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_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 __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_200] = { let __args: [G; IN_200] = [__v_2, __v_1]; 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_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_199] = [__v_3, __v_4]; + 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_188: usize = 2; -const IN_188: usize = 2; -const OUT_188: usize = 2; -fn aiur_fn_188( - inp: [G; IN_188], +const INPUT_SIZE_200: usize = 2; +const IN_200: usize = 2; +const OUT_200: usize = 2; +fn aiur_fn_200( + inp: [G; IN_200], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_188], ExecError> { +) -> 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]; @@ -18091,64 +19008,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_200] = [__v_4, __v_0]; + 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 __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_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 __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_202] = { let __args: [G; IN_202] = [__v_3, __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_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_200] = { let __args: [G; IN_200] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __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_200] = [__v_11, __v_9]; + 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_189: usize = 1; -const IN_189: usize = 1; -const OUT_189: usize = 2; -fn aiur_fn_189( - inp: [G; IN_189], +const INPUT_SIZE_201: usize = 1; +const IN_201: usize = 1; +const OUT_201: usize = 2; +fn aiur_fn_201( + inp: [G; IN_201], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_189], ExecError> { +) -> Result<[G; OUT_201], 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_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 __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_202] = { let __args: [G; IN_202] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_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_201] = [__v_3, __v_4]; + 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); }) } -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_202: usize = 2; +const IN_202: usize = 2; +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_190], ExecError> { +) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18157,12 +19074,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_202] = [__v_4, __v_0]; + 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); }, _ => { - 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_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -18174,28 +19091,28 @@ 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_202] = { let __args: [G; IN_202] = [__v_10, __v_12]; 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_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_202] = [__v_16, __v_14]; + 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); }, } }) } -const INPUT_SIZE_191: usize = 16; -const IN_191: usize = 16; -const OUT_191: usize = 0; -fn aiur_fn_191( - inp: [G; IN_191], +const INPUT_SIZE_203: usize = 16; +const IN_203: usize = 16; +const OUT_203: usize = 0; +fn aiur_fn_203( + inp: [G; IN_203], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_191], ExecError> { +) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -18218,961 +19135,1002 @@ 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_28] = { let __args: [G; IN_28] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_32] = { let __args: [G; IN_32] = [__v_21, __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 __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_37] = { let __args: [G; IN_37] = [__v_23]; 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_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_37] = { let __args: [G; IN_37] = [__v_25]; 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_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_37] = { let __args: [G; IN_37] = [__v_27]; 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_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_35] = { let __args: [G; IN_35] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } }; let __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_28] = { let __args: [G; IN_28] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_32] = { let __args: [G; IN_32] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } }; let __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_28] = { let __args: [G; IN_28] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_49] = { let __args: [G; IN_49] = [__v_37, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } }; let __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_33] = { let __args: [G; IN_33] = [__v_39]; 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_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_28] = { let __args: [G; IN_28] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_53] = { let __args: [G; IN_53] = [__v_43, __v_42]; 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 __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_28] = { let __args: [G; IN_28] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } }; let __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_56] = { let __args: [G; IN_56] = [__v_47, __v_46]; 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 __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; - let __v_50: G = __r_arr[2]; - let __v_51: G = __r_arr[3]; - let __v_52: G = __r_arr[4]; - let __v_53: G = __r_arr[5]; - let __v_54: G = __r_arr[6]; - let __v_55: G = __r_arr[7]; - let __v_56: G = __r_arr[8]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_57: G = __r_arr[0]; - let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; - let __v_59: G = __r_arr[0]; - let __v_60: G = __r_arr[1]; - let __v_61: G = __r_arr[2]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_62: G = __r_arr[0]; - let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } }; - let __v_64: G = __r_arr[0]; - let __v_65: G = __r_arr[1]; - let __v_66: G = G::from_u64(1); - let __v_67: G = G::from_u64(0); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_67]; let __info = io_buffer.get_info(__v_66, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_68: G = __io_pair.0; - let __v_69: G = __io_pair.1; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_49]; 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_50: G = __r_arr[0]; + let __v_51: G = __r_arr[1]; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_51]; 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_52: G = __r_arr[0]; + let __v_53: G = __r_arr[1]; + let __v_54: G = __r_arr[2]; + let __v_55: G = __r_arr[3]; + let __v_56: G = __r_arr[4]; + let __v_57: G = __r_arr[5]; + let __v_58: G = __r_arr[6]; + let __v_59: G = __r_arr[7]; + let __v_60: G = __r_arr[8]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_60]; 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_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_62]; 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_63: G = __r_arr[0]; + let __v_64: G = __r_arr[1]; + let __v_65: G = __r_arr[2]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_65]; 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_66: G = __r_arr[0]; + let __v_67: G = __r_arr[1]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_67]; 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_68: G = __r_arr[0]; + let __v_69: G = __r_arr[1]; let __v_70: G = G::from_u64(1); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_70, __v_68, __v_69]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; - let __v_71: G = __r_arr[0]; - let __v_72: G = G::from_u64(103); - let __v_73: G = G::from_u64(230); - let __v_74: G = G::from_u64(9); - let __v_75: G = G::from_u64(106); - let __v_76: G = G::from_u64(133); - let __v_77: G = G::from_u64(174); - let __v_78: G = G::from_u64(103); - let __v_79: G = G::from_u64(187); - let __v_80: G = G::from_u64(114); - let __v_81: G = G::from_u64(243); - let __v_82: G = G::from_u64(110); - let __v_83: G = G::from_u64(60); - let __v_84: G = G::from_u64(58); - let __v_85: G = G::from_u64(245); - let __v_86: G = G::from_u64(79); - let __v_87: G = G::from_u64(165); - let __v_88: G = G::from_u64(127); - let __v_89: G = G::from_u64(82); - let __v_90: G = G::from_u64(14); - let __v_91: G = G::from_u64(81); - let __v_92: G = G::from_u64(140); - let __v_93: G = G::from_u64(104); - let __v_94: G = G::from_u64(5); - let __v_95: G = G::from_u64(155); - let __v_96: G = G::from_u64(171); - let __v_97: G = G::from_u64(217); - let __v_98: G = G::from_u64(131); - let __v_99: G = G::from_u64(31); - let __v_100: G = G::from_u64(25); - let __v_101: G = G::from_u64(205); - let __v_102: G = G::from_u64(224); - let __v_103: G = G::from_u64(91); - let __v_104: G = G::from_u64(1); - let __v_105: G = G::from_u64(1); - let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_107: G = G::from_u64(0); - let __v_108: G = G::from_u64(0); - let __v_109: G = G::from_u64(0); - let __v_110: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_71]; let __info = io_buffer.get_info(__v_70, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_72: G = __io_pair.0; + let __v_73: G = __io_pair.1; + let __v_74: G = G::from_u64(1); + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_74, __v_72, __v_73]; let __cu = true; 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 { 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_75: G = __r_arr[0]; + let __v_76: G = G::from_u64(103); + let __v_77: G = G::from_u64(230); + let __v_78: G = G::from_u64(9); + let __v_79: G = G::from_u64(106); + let __v_80: G = G::from_u64(133); + let __v_81: G = G::from_u64(174); + let __v_82: G = G::from_u64(103); + let __v_83: G = G::from_u64(187); + let __v_84: G = G::from_u64(114); + let __v_85: G = G::from_u64(243); + let __v_86: G = G::from_u64(110); + let __v_87: G = G::from_u64(60); + let __v_88: G = G::from_u64(58); + let __v_89: G = G::from_u64(245); + let __v_90: G = G::from_u64(79); + let __v_91: G = G::from_u64(165); + let __v_92: G = G::from_u64(127); + let __v_93: G = G::from_u64(82); + let __v_94: G = G::from_u64(14); + let __v_95: G = G::from_u64(81); + let __v_96: G = G::from_u64(140); + let __v_97: G = G::from_u64(104); + let __v_98: G = G::from_u64(5); + let __v_99: G = G::from_u64(155); + let __v_100: G = G::from_u64(171); + let __v_101: G = G::from_u64(217); + let __v_102: G = G::from_u64(131); + let __v_103: G = G::from_u64(31); + let __v_104: G = G::from_u64(25); + let __v_105: G = G::from_u64(205); + let __v_106: G = G::from_u64(224); + let __v_107: G = G::from_u64(91); + let __v_108: G = G::from_u64(1); + let __v_109: G = G::from_u64(1); + let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0); let __v_112: G = G::from_u64(0); let __v_113: G = G::from_u64(0); let __v_114: G = G::from_u64(0); let __v_115: G = G::from_u64(0); let __v_116: G = G::from_u64(0); - let __v_117: G = { let __values: [G; 8] = [__v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_118: G = { let __values: [G; 32] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_119: G = G::from_u64(1); - let __v_120: G = G::from_u64(1); - let __v_121: G = { let __values: [G; 34] = [__v_119, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_71, __v_106, __v_107, __v_108, __v_117, __v_118, __v_121]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; - let __v_122: G = __r_arr[0]; - let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; - let __v_123: G = __r_arr[0]; - let __v_124: G = __r_arr[1]; - let __v_125: G = __r_arr[2]; - let __v_126: G = __r_arr[3]; - let __v_127: G = __r_arr[4]; - let __v_128: G = __r_arr[5]; - let __v_129: G = __r_arr[6]; - let __v_130: G = __r_arr[7]; - let __v_131: G = __r_arr[8]; - let __v_132: G = __r_arr[9]; - let __v_133: G = __r_arr[10]; - let __v_134: G = __r_arr[11]; - let __v_135: G = __r_arr[12]; - let __v_136: G = __r_arr[13]; - let __v_137: G = __r_arr[14]; - let __v_138: G = __r_arr[15]; - let __v_139: G = __r_arr[16]; - let __v_140: G = __r_arr[17]; - let __v_141: G = __r_arr[18]; - let __v_142: G = __r_arr[19]; - let __v_143: G = __r_arr[20]; - let __v_144: G = __r_arr[21]; - let __v_145: G = __r_arr[22]; - let __v_146: G = __r_arr[23]; - let __v_147: G = __r_arr[24]; - let __v_148: G = __r_arr[25]; - let __v_149: G = __r_arr[26]; - let __v_150: G = __r_arr[27]; - let __v_151: G = __r_arr[28]; - let __v_152: G = __r_arr[29]; - let __v_153: G = __r_arr[30]; - let __v_154: G = __r_arr[31]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_155: G = __r_arr[0]; - let __v_156: G = __r_arr[1]; - let __v_157: G = __r_arr[2]; - let __v_158: G = __r_arr[3]; - let __v_159: G = __r_arr[4]; - let __v_160: G = __r_arr[5]; - let __v_161: G = __r_arr[6]; - let __v_162: G = __r_arr[7]; - let __v_163: G = __r_arr[8]; - let __v_164: G = __r_arr[9]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_164]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_165: G = __r_arr[0]; - let __v_166: G = __r_arr[1]; - let __v_167: G = __r_arr[2]; - let __v_168: G = __r_arr[3]; - let __v_169: G = __r_arr[4]; - let __v_170: G = __r_arr[5]; - let __v_171: G = __r_arr[6]; - let __v_172: G = __r_arr[7]; - let __v_173: G = __r_arr[8]; - let __v_174: G = __r_arr[9]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_174]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_175: G = __r_arr[0]; - let __v_176: G = __r_arr[1]; - let __v_177: G = __r_arr[2]; - let __v_178: G = __r_arr[3]; - let __v_179: G = __r_arr[4]; - let __v_180: G = __r_arr[5]; - let __v_181: G = __r_arr[6]; - let __v_182: G = __r_arr[7]; - let __v_183: G = __r_arr[8]; - let __v_184: G = __r_arr[9]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_184]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_185: G = __r_arr[0]; - let __v_186: G = __r_arr[1]; - let __v_187: G = __r_arr[2]; - let __v_188: G = __r_arr[3]; - let __v_189: G = __r_arr[4]; - let __v_190: G = __r_arr[5]; - let __v_191: G = __r_arr[6]; - let __v_192: G = __r_arr[7]; - let __v_193: G = __r_arr[8]; - let __v_194: G = __r_arr[9]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_194]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_195: G = __r_arr[0]; - let __v_196: G = __r_arr[1]; - let __v_197: G = __r_arr[2]; - let __v_198: G = __r_arr[3]; - let __v_199: G = __r_arr[4]; - let __v_200: G = __r_arr[5]; - let __v_201: G = __r_arr[6]; - let __v_202: G = __r_arr[7]; - let __v_203: G = __r_arr[8]; - let __v_204: G = __r_arr[9]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_204]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_205: G = __r_arr[0]; - let __v_206: G = __r_arr[1]; - let __v_207: G = __r_arr[2]; - let __v_208: G = __r_arr[3]; - let __v_209: G = __r_arr[4]; - let __v_210: G = __r_arr[5]; - let __v_211: G = __r_arr[6]; - let __v_212: G = __r_arr[7]; - let __v_213: G = __r_arr[8]; - let __v_214: G = __r_arr[9]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_214]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_215: G = __r_arr[0]; - let __v_216: G = __r_arr[1]; - let __v_217: G = __r_arr[2]; - let __v_218: G = __r_arr[3]; - let __v_219: G = __r_arr[4]; - let __v_220: G = __r_arr[5]; - let __v_221: G = __r_arr[6]; - let __v_222: G = __r_arr[7]; - let __v_223: G = __r_arr[8]; - let __v_224: G = __r_arr[9]; - let __v_225: G = G::from_u64(0); - let __v_226: G = G::from_u64(0); - let __v_227: G = G::from_u64(0); - let __v_228: G = G::from_u64(0); + let __v_117: G = G::from_u64(0); + let __v_118: G = G::from_u64(0); + let __v_119: G = G::from_u64(0); + let __v_120: G = G::from_u64(0); + let __v_121: G = { let __values: [G; 8] = [__v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_122: G = { let __values: [G; 32] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_123: G = G::from_u64(1); + let __v_124: G = G::from_u64(1); + let __v_125: G = { let __values: [G; 34] = [__v_123, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_75, __v_110, __v_111, __v_112, __v_121, __v_122, __v_125]; 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_126: G = __r_arr[0]; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_126]; 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_127: G = __r_arr[0]; + let __v_128: G = __r_arr[1]; + let __v_129: G = __r_arr[2]; + let __v_130: G = __r_arr[3]; + let __v_131: G = __r_arr[4]; + let __v_132: G = __r_arr[5]; + let __v_133: G = __r_arr[6]; + let __v_134: G = __r_arr[7]; + let __v_135: G = __r_arr[8]; + let __v_136: G = __r_arr[9]; + let __v_137: G = __r_arr[10]; + let __v_138: G = __r_arr[11]; + let __v_139: G = __r_arr[12]; + let __v_140: G = __r_arr[13]; + let __v_141: G = __r_arr[14]; + let __v_142: G = __r_arr[15]; + let __v_143: G = __r_arr[16]; + let __v_144: G = __r_arr[17]; + let __v_145: G = __r_arr[18]; + let __v_146: G = __r_arr[19]; + let __v_147: G = __r_arr[20]; + let __v_148: G = __r_arr[21]; + let __v_149: G = __r_arr[22]; + let __v_150: G = __r_arr[23]; + let __v_151: G = __r_arr[24]; + let __v_152: G = __r_arr[25]; + let __v_153: G = __r_arr[26]; + let __v_154: G = __r_arr[27]; + let __v_155: G = __r_arr[28]; + let __v_156: G = __r_arr[29]; + let __v_157: G = __r_arr[30]; + let __v_158: G = __r_arr[31]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_75]; 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_159: G = __r_arr[0]; + let __v_160: G = __r_arr[1]; + let __v_161: G = __r_arr[2]; + let __v_162: G = __r_arr[3]; + let __v_163: G = __r_arr[4]; + let __v_164: G = __r_arr[5]; + let __v_165: G = __r_arr[6]; + let __v_166: G = __r_arr[7]; + let __v_167: G = __r_arr[8]; + let __v_168: G = __r_arr[9]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_168]; 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_169: G = __r_arr[0]; + let __v_170: G = __r_arr[1]; + let __v_171: G = __r_arr[2]; + let __v_172: G = __r_arr[3]; + let __v_173: G = __r_arr[4]; + let __v_174: G = __r_arr[5]; + let __v_175: G = __r_arr[6]; + let __v_176: G = __r_arr[7]; + let __v_177: G = __r_arr[8]; + let __v_178: G = __r_arr[9]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_178]; 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_179: G = __r_arr[0]; + let __v_180: G = __r_arr[1]; + let __v_181: G = __r_arr[2]; + let __v_182: G = __r_arr[3]; + let __v_183: G = __r_arr[4]; + let __v_184: G = __r_arr[5]; + let __v_185: G = __r_arr[6]; + let __v_186: G = __r_arr[7]; + let __v_187: G = __r_arr[8]; + let __v_188: G = __r_arr[9]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_188]; 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_189: G = __r_arr[0]; + let __v_190: G = __r_arr[1]; + let __v_191: G = __r_arr[2]; + let __v_192: G = __r_arr[3]; + let __v_193: G = __r_arr[4]; + let __v_194: G = __r_arr[5]; + let __v_195: G = __r_arr[6]; + let __v_196: G = __r_arr[7]; + let __v_197: G = __r_arr[8]; + let __v_198: G = __r_arr[9]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_198]; 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_199: G = __r_arr[0]; + let __v_200: G = __r_arr[1]; + let __v_201: G = __r_arr[2]; + let __v_202: G = __r_arr[3]; + let __v_203: G = __r_arr[4]; + let __v_204: G = __r_arr[5]; + let __v_205: G = __r_arr[6]; + let __v_206: G = __r_arr[7]; + let __v_207: G = __r_arr[8]; + let __v_208: G = __r_arr[9]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_208]; 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_209: G = __r_arr[0]; + let __v_210: G = __r_arr[1]; + let __v_211: G = __r_arr[2]; + let __v_212: G = __r_arr[3]; + let __v_213: G = __r_arr[4]; + let __v_214: G = __r_arr[5]; + let __v_215: G = __r_arr[6]; + let __v_216: G = __r_arr[7]; + let __v_217: G = __r_arr[8]; + let __v_218: G = __r_arr[9]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_218]; 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_219: G = __r_arr[0]; + let __v_220: G = __r_arr[1]; + let __v_221: G = __r_arr[2]; + let __v_222: G = __r_arr[3]; + let __v_223: G = __r_arr[4]; + let __v_224: G = __r_arr[5]; + let __v_225: G = __r_arr[6]; + let __v_226: G = __r_arr[7]; + let __v_227: G = __r_arr[8]; + let __v_228: G = __r_arr[9]; let __v_229: G = G::from_u64(0); let __v_230: G = G::from_u64(0); let __v_231: G = G::from_u64(0); - let __v_232: G = G::from_u64(1); - let __v_233: G = G::from_u64(1); - let __v_234: G = { let __values: [G; 10] = [__v_232, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_235: G = { let __values: [G; 10] = [__v_231, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_234]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_236: G = { let __values: [G; 10] = [__v_230, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_235]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_237: G = { let __values: [G; 10] = [__v_229, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_236]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_238: G = { let __values: [G; 10] = [__v_228, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_237]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_239: G = { let __values: [G; 10] = [__v_227, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_238]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_240: G = { let __values: [G; 10] = [__v_226, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_239]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_241: G = { let __values: [G; 10] = [__v_225, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_240]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_224]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } }; - let __v_242: G = __r_arr[0]; - let __v_243: G = __r_arr[1]; - let __v_244: G = __r_arr[2]; - let __v_245: G = __r_arr[3]; - let __v_246: G = __r_arr[4]; - let __v_247: G = __r_arr[5]; - let __v_248: G = __r_arr[6]; - let __v_249: G = __r_arr[7]; - let __v_250: G = __r_arr[8]; - let __v_251: G = __r_arr[9]; - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_251, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; - let __v_252: G = __r_arr[0]; - let __v_253: G = __r_arr[1]; - let __v_254: G = __r_arr[2]; - let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_254]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; - let __v_255: G = __r_arr[0]; - let __v_256: G = __r_arr[1]; - let __v_257: G = __r_arr[2]; - let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_257, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; - let __v_258: G = __r_arr[0]; - let __v_259: G = __r_arr[1]; - let __v_260: G = G::from_u64(0); - let __v_261: G = { let __values: [G; 10] = [__v_260, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_253]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_241, __v_261]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __v_232: G = G::from_u64(0); + let __v_233: G = G::from_u64(0); + let __v_234: G = G::from_u64(0); + let __v_235: G = G::from_u64(0); + let __v_236: G = G::from_u64(1); + let __v_237: G = G::from_u64(1); + let __v_238: G = { let __values: [G; 10] = [__v_236, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_239: G = { let __values: [G; 10] = [__v_235, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_238]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_234, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_239]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_233, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_240]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_242: G = { let __values: [G; 10] = [__v_232, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_241]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_243: G = { let __values: [G; 10] = [__v_231, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_242]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_244: G = { let __values: [G; 10] = [__v_230, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_243]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 10] = [__v_229, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_244]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_228]; 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_246: G = __r_arr[0]; + let __v_247: G = __r_arr[1]; + let __v_248: G = __r_arr[2]; + let __v_249: G = __r_arr[3]; + let __v_250: G = __r_arr[4]; + let __v_251: G = __r_arr[5]; + let __v_252: G = __r_arr[6]; + let __v_253: G = __r_arr[7]; + let __v_254: G = __r_arr[8]; + let __v_255: G = __r_arr[9]; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_255, __v_246]; 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_256: G = __r_arr[0]; + let __v_257: G = __r_arr[1]; + let __v_258: G = __r_arr[2]; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_258]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; + let __v_259: G = __r_arr[0]; + let __v_260: G = __r_arr[1]; + let __v_261: G = __r_arr[2]; + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_261, __v_246]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; - let __v_263: G = G::from_u64(2); + let __v_263: G = __r_arr[1]; 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_265: G = { let __values: [G; 10] = [__v_264, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_257]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_245, __v_265]; 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_266: G = __r_arr[0]; let __v_267: G = G::from_u64(2); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_267, __v_265, __v_266]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; - let __v_268: G = __r_arr[0]; - let __v_269: G = G::from_u64(103); - let __v_270: G = G::from_u64(230); - let __v_271: G = G::from_u64(9); - let __v_272: G = G::from_u64(106); - let __v_273: G = G::from_u64(133); - let __v_274: G = G::from_u64(174); - let __v_275: G = G::from_u64(103); - let __v_276: G = G::from_u64(187); - let __v_277: G = G::from_u64(114); - let __v_278: G = G::from_u64(243); - let __v_279: G = G::from_u64(110); - let __v_280: G = G::from_u64(60); - let __v_281: G = G::from_u64(58); - let __v_282: G = G::from_u64(245); - let __v_283: G = G::from_u64(79); - let __v_284: G = G::from_u64(165); - let __v_285: G = G::from_u64(127); - let __v_286: G = G::from_u64(82); - let __v_287: G = G::from_u64(14); - let __v_288: G = G::from_u64(81); - let __v_289: G = G::from_u64(140); - let __v_290: G = G::from_u64(104); - let __v_291: G = G::from_u64(5); - let __v_292: G = G::from_u64(155); - let __v_293: G = G::from_u64(171); - let __v_294: G = G::from_u64(217); - let __v_295: G = G::from_u64(131); - let __v_296: G = G::from_u64(31); - let __v_297: G = G::from_u64(25); - let __v_298: G = G::from_u64(205); - let __v_299: G = G::from_u64(224); - let __v_300: G = G::from_u64(91); - let __v_301: G = G::from_u64(1); - let __v_302: G = G::from_u64(1); - let __v_303: G = { let __values: [G; 3] = [__v_301, __v_302, __v_302]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_304: G = G::from_u64(0); - let __v_305: G = G::from_u64(0); - let __v_306: G = G::from_u64(0); - let __v_307: G = G::from_u64(0); + let __v_268: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_268]; let __info = io_buffer.get_info(__v_267, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_269: G = __io_pair.0; + let __v_270: G = __io_pair.1; + let __v_271: G = G::from_u64(2); + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_271, __v_269, __v_270]; let __cu = true; 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 { 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_272: G = __r_arr[0]; + let __v_273: G = G::from_u64(103); + let __v_274: G = G::from_u64(230); + let __v_275: G = G::from_u64(9); + let __v_276: G = G::from_u64(106); + let __v_277: G = G::from_u64(133); + let __v_278: G = G::from_u64(174); + let __v_279: G = G::from_u64(103); + let __v_280: G = G::from_u64(187); + let __v_281: G = G::from_u64(114); + let __v_282: G = G::from_u64(243); + let __v_283: G = G::from_u64(110); + let __v_284: G = G::from_u64(60); + let __v_285: G = G::from_u64(58); + let __v_286: G = G::from_u64(245); + let __v_287: G = G::from_u64(79); + let __v_288: G = G::from_u64(165); + let __v_289: G = G::from_u64(127); + let __v_290: G = G::from_u64(82); + let __v_291: G = G::from_u64(14); + let __v_292: G = G::from_u64(81); + let __v_293: G = G::from_u64(140); + let __v_294: G = G::from_u64(104); + let __v_295: G = G::from_u64(5); + let __v_296: G = G::from_u64(155); + let __v_297: G = G::from_u64(171); + let __v_298: G = G::from_u64(217); + let __v_299: G = G::from_u64(131); + let __v_300: G = G::from_u64(31); + let __v_301: G = G::from_u64(25); + let __v_302: G = G::from_u64(205); + let __v_303: G = G::from_u64(224); + let __v_304: G = G::from_u64(91); + let __v_305: G = G::from_u64(1); + let __v_306: G = G::from_u64(1); + let __v_307: G = { let __values: [G; 3] = [__v_305, __v_306, __v_306]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; 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_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 __v_314: G = G::from_u64(0); + let __v_315: G = G::from_u64(0); + let __v_316: G = G::from_u64(0); + let __v_317: G = G::from_u64(0); + let __v_318: G = { let __values: [G; 8] = [__v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317]; 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_319: G = { let __values: [G; 32] = [__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, __v_301, __v_302, __v_303, __v_304]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_320: G = G::from_u64(1); + let __v_321: G = G::from_u64(1); + let __v_322: G = { let __values: [G; 34] = [__v_320, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321]; 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_272, __v_307, __v_308, __v_309, __v_318, __v_319, __v_322]; 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_323: G = __r_arr[0]; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_323]; 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_324: G = __r_arr[0]; + let __v_325: G = __r_arr[1]; + let __v_326: G = __r_arr[2]; + let __v_327: G = __r_arr[3]; + let __v_328: G = __r_arr[4]; + let __v_329: G = __r_arr[5]; + let __v_330: G = __r_arr[6]; + let __v_331: G = __r_arr[7]; + let __v_332: G = __r_arr[8]; + let __v_333: G = __r_arr[9]; + let __v_334: G = __r_arr[10]; + let __v_335: G = __r_arr[11]; + let __v_336: G = __r_arr[12]; + let __v_337: G = __r_arr[13]; + let __v_338: G = __r_arr[14]; + let __v_339: G = __r_arr[15]; + let __v_340: G = __r_arr[16]; + let __v_341: G = __r_arr[17]; + let __v_342: G = __r_arr[18]; + let __v_343: G = __r_arr[19]; + let __v_344: G = __r_arr[20]; + let __v_345: G = __r_arr[21]; + let __v_346: G = __r_arr[22]; + let __v_347: G = __r_arr[23]; + let __v_348: G = __r_arr[24]; + let __v_349: G = __r_arr[25]; + let __v_350: G = __r_arr[26]; + let __v_351: G = __r_arr[27]; + let __v_352: G = __r_arr[28]; + let __v_353: G = __r_arr[29]; + let __v_354: G = __r_arr[30]; + let __v_355: G = __r_arr[31]; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_272]; 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_356: G = __r_arr[0]; + let __v_357: G = __r_arr[1]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_357, __v_356]; 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_358: G = __r_arr[0]; + let __v_359: 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_206] = { let __args: [G; IN_206] = [__v_30]; 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_360: G = __r_arr[0]; + let __v_361: G = G::from_bool((__v_360 == G::ZERO)); + let __v_362: G = G::from_u64(0); + if (__v_361 != __v_362) { + return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_362.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_205] = { let __args: [G; IN_205] = [__v_66]; 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_363: G = __r_arr[0]; + if (__v_363 != __v_360) { + return Err(ExecError::AssertEqMismatch { lhs: __v_363.as_canonical_u64(), rhs: __v_360.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_205] = { let __args: [G; IN_205] = [__v_68]; 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_364: G = __r_arr[0]; + if (__v_364 != __v_360) { + return Err(ExecError::AssertEqMismatch { lhs: __v_364.as_canonical_u64(), rhs: __v_360.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_205] = { let __args: [G; IN_205] = [__v_61]; 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_365: G = __r_arr[0]; + if (__v_365 != __v_360) { + return Err(ExecError::AssertEqMismatch { lhs: __v_365.as_canonical_u64(), rhs: __v_360.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_157] = { let __args: [G; IN_157] = [__v_30]; 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_366: G = __r_arr[0]; + let __v_367: G = G::from_u64(1); + if (__v_366 != __v_367) { + return Err(ExecError::AssertEqMismatch { lhs: __v_366.as_canonical_u64(), rhs: __v_367.as_canonical_u64(), msg: None }); } - let __v_364: G = G::from_u64(1); - break '__mc_0 [__v_364]; + let __v_368: G = G::from_u64(1); + break '__mc_0 [__v_368]; }, } }; - let __v_356: G = __mc_out___mc_0[0]; - let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_155.as_canonical_u64() { + let __v_360: G = __mc_out___mc_0[0]; + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_159.as_canonical_u64() { _ => { - match __v_155.as_canonical_u64() { + match __v_159.as_canonical_u64() { _ => { match __v_22.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_252, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; - let __v_357: G = __r_arr[0]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_258, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; - let __v_358: G = __r_arr[0]; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_256, __v_22]; 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_361: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_262, __v_22]; 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_362: G = __r_arr[0]; match __v_24.as_canonical_u64() { _ => { - let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_255.as_canonical_u64() { + let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_259.as_canonical_u64() { 0u64 => { - let __v_359: G = G::from_u64(1); - let __v_360: G = G::from_u64(1); - let __v_361: G = { let __values: [G; 3] = [__v_359, __v_360, __v_360]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - break '__mc_2 [__v_361]; + let __v_363: G = G::from_u64(1); + let __v_364: G = G::from_u64(1); + let __v_365: G = { let __values: [G; 3] = [__v_363, __v_364, __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 } }; + break '__mc_2 [__v_365]; }, 1u64 => { - break '__mc_2 [__v_256]; + break '__mc_2 [__v_260]; }, _ => { - return Err(ExecError::MatchNoCase(__v_255.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_259.as_canonical_u64())); }, } }; - let __v_359: G = __mc_out___mc_2[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_34, __v_268]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; - let __v_360: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_24, __v_360]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; - let __v_361: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_359, __v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; - let __v_362: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_22, __v_362]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; - let __v_363: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_262, __v_363]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __v_363: G = __mc_out___mc_2[0]; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_34, __v_272]; 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_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 __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_24, __v_364]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __v_365: G = __r_arr[0]; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_363, __v_365]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __v_366: G = __r_arr[0]; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_22, __v_366]; 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_367: G = __r_arr[0]; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_266, __v_367]; 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_368: G = __r_arr[0]; let __v_369: G = G::from_u64(0); - let __v_370: G = G::from_u64(108); + let __v_370: G = G::from_u64(109); let __v_371: G = G::from_u64(0); - let __v_372: G = G::from_u64(116); + let __v_372: G = G::from_u64(117); let __v_373: G = G::from_u64(0); - let __v_374: G = G::from_u64(105); + let __v_374: G = G::from_u64(108); let __v_375: G = G::from_u64(0); - let __v_376: G = G::from_u64(45); + let __v_376: G = G::from_u64(116); let __v_377: G = G::from_u64(0); - let __v_378: G = G::from_u64(115); + let __v_378: G = G::from_u64(105); let __v_379: G = G::from_u64(0); - let __v_380: G = G::from_u64(116); + let __v_380: G = G::from_u64(45); let __v_381: G = G::from_u64(0); - let __v_382: G = G::from_u64(97); + let __v_382: G = G::from_u64(115); let __v_383: G = G::from_u64(0); - let __v_384: G = G::from_u64(114); + let __v_384: G = G::from_u64(116); let __v_385: G = G::from_u64(0); - let __v_386: G = G::from_u64(107); + let __v_386: G = G::from_u64(97); let __v_387: G = G::from_u64(0); - let __v_388: G = G::from_u64(47); + let __v_388: G = G::from_u64(114); let __v_389: G = G::from_u64(0); - let __v_390: G = G::from_u64(118); + let __v_390: G = G::from_u64(107); let __v_391: G = G::from_u64(0); - let __v_392: G = G::from_u64(48); - let __v_393: G = { let __values: [G; 3] = [__v_391, __v_392, __v_364]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_394: G = { let __values: [G; 3] = [__v_389, __v_390, __v_393]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_395: G = { let __values: [G; 3] = [__v_387, __v_388, __v_394]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_396: G = { let __values: [G; 3] = [__v_385, __v_386, __v_395]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_397: G = { let __values: [G; 3] = [__v_383, __v_384, __v_396]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_398: G = { let __values: [G; 3] = [__v_381, __v_382, __v_397]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_399: G = { let __values: [G; 3] = [__v_379, __v_380, __v_398]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_400: G = { let __values: [G; 3] = [__v_377, __v_378, __v_399]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_401: G = { let __values: [G; 3] = [__v_375, __v_376, __v_400]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_402: G = { let __values: [G; 3] = [__v_373, __v_374, __v_401]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_403: G = { let __values: [G; 3] = [__v_371, __v_372, __v_402]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_404: G = { let __values: [G; 3] = [__v_369, __v_370, __v_403]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_405: G = { let __values: [G; 3] = [__v_367, __v_368, __v_404]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_406: G = { let __values: [G; 3] = [__v_365, __v_366, __v_405]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_407: G = G::from_u64(1); - let __v_408: G = G::from_u64(1); - let __v_409: G = { let __values: [G; 3] = [__v_407, __v_408, __v_408]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_406, __v_409]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; - let __v_410: G = __r_arr[0]; - let __v_411: G = __r_arr[1]; - let __v_412: G = __r_arr[2]; - let __v_413: G = __r_arr[3]; - let __v_414: G = __r_arr[4]; - let __v_415: G = __r_arr[5]; - let __v_416: G = __r_arr[6]; - let __v_417: G = __r_arr[7]; - let __v_418: G = __r_arr[8]; - let __v_419: G = __r_arr[9]; - let __v_420: G = __r_arr[10]; - let __v_421: G = __r_arr[11]; - let __v_422: G = __r_arr[12]; - let __v_423: G = __r_arr[13]; - let __v_424: G = __r_arr[14]; - let __v_425: G = __r_arr[15]; - let __v_426: G = __r_arr[16]; - let __v_427: G = __r_arr[17]; - let __v_428: G = G::from_u64(1); - let __v_429: G = G::from_u64(1); - let __v_430: G = { let __values: [G; 3] = [__v_428, __v_429, __v_429]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_430]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; - let __v_431: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_431]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; - let __v_432: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_426, __v_432]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; - let __v_433: G = __r_arr[0]; - let __v_434: G = G::from_u64(1); - let __v_435: G = G::from_u64(1); - let __v_436: G = { let __values: [G; 3] = [__v_434, __v_435, __v_435]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_433, __v_436]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_392: G = G::from_u64(47); + let __v_393: G = G::from_u64(0); + let __v_394: G = G::from_u64(118); + let __v_395: G = G::from_u64(0); + let __v_396: G = G::from_u64(48); + let __v_397: G = { let __values: [G; 3] = [__v_395, __v_396, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_393, __v_394, __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_391, __v_392, __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_389, __v_390, __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_387, __v_388, __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_385, __v_386, __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_383, __v_384, __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_381, __v_382, __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_379, __v_380, __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_377, __v_378, __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 = { let __values: [G; 3] = [__v_375, __v_376, __v_406]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_408: G = { let __values: [G; 3] = [__v_373, __v_374, __v_407]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_409: G = { let __values: [G; 3] = [__v_371, __v_372, __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 __v_410: G = { let __values: [G; 3] = [__v_369, __v_370, __v_409]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_411: G = G::from_u64(1); + let __v_412: G = G::from_u64(1); + let __v_413: G = { let __values: [G; 3] = [__v_411, __v_412, __v_412]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_410, __v_413]; 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_414: G = __r_arr[0]; + let __v_415: G = __r_arr[1]; + let __v_416: G = __r_arr[2]; + let __v_417: G = __r_arr[3]; + let __v_418: G = __r_arr[4]; + let __v_419: G = __r_arr[5]; + let __v_420: G = __r_arr[6]; + let __v_421: G = __r_arr[7]; + let __v_422: G = __r_arr[8]; + let __v_423: G = __r_arr[9]; + let __v_424: G = __r_arr[10]; + let __v_425: G = __r_arr[11]; + let __v_426: G = __r_arr[12]; + let __v_427: G = __r_arr[13]; + let __v_428: G = __r_arr[14]; + let __v_429: G = __r_arr[15]; + let __v_430: G = __r_arr[16]; + let __v_431: G = __r_arr[17]; + let __v_432: G = G::from_u64(1); + let __v_433: G = G::from_u64(1); + let __v_434: G = { let __values: [G; 3] = [__v_432, __v_433, __v_433]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_434]; 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_435: G = __r_arr[0]; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_435]; 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_436: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_430, __v_436]; 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_437: G = __r_arr[0]; - let __v_438: G = __r_arr[1]; - let __v_439: G = __r_arr[2]; - let __v_440: G = __r_arr[3]; - let __v_441: G = __r_arr[4]; - let __v_442: G = __r_arr[5]; - let __v_443: G = __r_arr[6]; - let __v_444: G = __r_arr[7]; - let __v_445: G = __r_arr[8]; - let __v_446: G = __r_arr[9]; - let __v_447: G = __r_arr[10]; - let __v_448: G = __r_arr[11]; - let __v_449: G = __r_arr[12]; - let __v_450: G = __r_arr[13]; - let __v_451: G = __r_arr[14]; - let __v_452: G = __r_arr[15]; - let __v_453: G = __r_arr[16]; - let __v_454: G = __r_arr[17]; - let __v_455: G = G::from_u64(1); - let __v_456: G = G::from_u64(1); - let __v_457: G = { let __values: [G; 3] = [__v_455, __v_456, __v_456]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_445, __v_446, __v_447, __v_448, __v_449, __v_450, __v_451, __v_452, __v_457]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; - let __v_458: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_437, __v_438, __v_439, __v_440, __v_441, __v_442, __v_443, __v_444, __v_458]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; - let __v_459: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_453, __v_459]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; - let __v_460: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_460, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; - let __v_461: G = __r_arr[0]; - let __v_462: G = G::from_u64(1); - let __v_463: G = G::from_u64(1); - let __v_464: G = { let __values: [G; 3] = [__v_462, __v_463, __v_463]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_30, __v_464]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_438: G = G::from_u64(1); + let __v_439: G = G::from_u64(1); + let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_437, __v_440]; 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_441: G = __r_arr[0]; + let __v_442: G = __r_arr[1]; + let __v_443: G = __r_arr[2]; + let __v_444: G = __r_arr[3]; + let __v_445: G = __r_arr[4]; + let __v_446: G = __r_arr[5]; + let __v_447: G = __r_arr[6]; + let __v_448: G = __r_arr[7]; + let __v_449: G = __r_arr[8]; + let __v_450: G = __r_arr[9]; + let __v_451: G = __r_arr[10]; + let __v_452: G = __r_arr[11]; + let __v_453: G = __r_arr[12]; + let __v_454: G = __r_arr[13]; + let __v_455: G = __r_arr[14]; + let __v_456: G = __r_arr[15]; + let __v_457: G = __r_arr[16]; + let __v_458: G = __r_arr[17]; + let __v_459: G = G::from_u64(1); + let __v_460: G = G::from_u64(1); + let __v_461: G = { let __values: [G; 3] = [__v_459, __v_460, __v_460]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_449, __v_450, __v_451, __v_452, __v_453, __v_454, __v_455, __v_456, __v_461]; 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_462: G = __r_arr[0]; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_462]; 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_463: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_457, __v_463]; 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_464: G = __r_arr[0]; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_464, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_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_466: G = G::from_u64(1); 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_468: G = { let __values: [G; 3] = [__v_466, __v_467, __v_467]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_30, __v_468]; 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_469: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_465, __v_469]; 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_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_471: G = G::from_u64(1); + let __v_472: G = G::from_u64(1); + let __v_473: G = { let __values: [G; 3] = [__v_471, __v_472, __v_472]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_470, __v_473]; 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_474: G = __r_arr[0]; + let __v_475: G = __r_arr[1]; + let __v_476: G = __r_arr[2]; + let __v_477: G = __r_arr[3]; + let __v_478: G = __r_arr[4]; + let __v_479: G = __r_arr[5]; + let __v_480: G = __r_arr[6]; + let __v_481: G = __r_arr[7]; + let __v_482: G = __r_arr[8]; + let __v_483: G = __r_arr[9]; + let __v_484: G = __r_arr[10]; + let __v_485: G = __r_arr[11]; + let __v_486: G = __r_arr[12]; + let __v_487: G = __r_arr[13]; + let __v_488: G = __r_arr[14]; + let __v_489: G = __r_arr[15]; + let __v_490: G = __r_arr[16]; + let __v_491: G = __r_arr[17]; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_490, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_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_493: G = G::from_u64(1); + let __v_494: G = G::from_u64(1); + let __v_495: G = { let __values: [G; 3] = [__v_493, __v_494, __v_494]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_492, __v_495]; 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_496: G = __r_arr[0]; + let __v_497: G = __r_arr[1]; + let __v_498: G = __r_arr[2]; + let __v_499: G = __r_arr[3]; + let __v_500: G = __r_arr[4]; + let __v_501: G = __r_arr[5]; + let __v_502: G = __r_arr[6]; + let __v_503: G = __r_arr[7]; + let __v_504: G = __r_arr[8]; + let __v_505: G = __r_arr[9]; + let __v_506: G = __r_arr[10]; + let __v_507: G = __r_arr[11]; + let __v_508: G = __r_arr[12]; + let __v_509: G = __r_arr[13]; + let __v_510: G = __r_arr[14]; + let __v_511: G = __r_arr[15]; + let __v_512: G = __r_arr[16]; + let __v_513: G = __r_arr[17]; + let __v_514: G = G::from_u64(256); + let __v_515: G = (__v_514 * __v_415); + let __v_516: G = G::from_u64(65536); + let __v_517: G = (__v_516 * __v_416); + let __v_518: G = G::from_u64(16777216); + let __v_519: G = (__v_518 * __v_417); + let __v_520: G = G::from_u64(4294967296); + let __v_521: G = (__v_520 * __v_418); + let __v_522: G = G::from_u64(1099511627776); + let __v_523: G = (__v_522 * __v_419); + let __v_524: G = G::from_u64(281474976710656); + let __v_525: G = (__v_524 * __v_420); + let __v_526: G = G::from_u64(72057594037927936); + let __v_527: G = (__v_526 * __v_421); + let __v_528: G = (__v_525 + __v_527); + let __v_529: G = (__v_523 + __v_528); + let __v_530: G = (__v_521 + __v_529); + let __v_531: G = (__v_519 + __v_530); + let __v_532: G = (__v_517 + __v_531); + let __v_533: G = (__v_515 + __v_532); + let __v_534: G = (__v_414 + __v_533); + let __v_535: G = G::from_u64(256); + let __v_536: G = (__v_535 * __v_423); + let __v_537: G = G::from_u64(65536); + let __v_538: G = (__v_537 * __v_424); + let __v_539: G = G::from_u64(16777216); + let __v_540: G = (__v_539 * __v_425); + let __v_541: G = G::from_u64(4294967296); + let __v_542: G = (__v_541 * __v_426); + let __v_543: G = G::from_u64(1099511627776); + let __v_544: G = (__v_543 * __v_427); + let __v_545: G = G::from_u64(281474976710656); + let __v_546: G = (__v_545 * __v_428); + let __v_547: G = G::from_u64(72057594037927936); + let __v_548: G = (__v_547 * __v_429); + let __v_549: G = (__v_546 + __v_548); + let __v_550: G = (__v_544 + __v_549); + let __v_551: G = (__v_542 + __v_550); + let __v_552: G = (__v_540 + __v_551); + let __v_553: G = (__v_538 + __v_552); + let __v_554: G = (__v_536 + __v_553); + let __v_555: G = (__v_422 + __v_554); + let __v_556: G = G::from_u64(256); + let __v_557: G = (__v_556 * __v_442); + let __v_558: G = G::from_u64(65536); + let __v_559: G = (__v_558 * __v_443); + let __v_560: G = G::from_u64(16777216); + let __v_561: G = (__v_560 * __v_444); + let __v_562: G = G::from_u64(4294967296); + let __v_563: G = (__v_562 * __v_445); + let __v_564: G = G::from_u64(1099511627776); + let __v_565: G = (__v_564 * __v_446); + let __v_566: G = G::from_u64(281474976710656); + let __v_567: G = (__v_566 * __v_447); + let __v_568: G = G::from_u64(72057594037927936); + let __v_569: G = (__v_568 * __v_448); + let __v_570: G = (__v_567 + __v_569); + let __v_571: G = (__v_565 + __v_570); + let __v_572: G = (__v_563 + __v_571); + let __v_573: G = (__v_561 + __v_572); + let __v_574: G = (__v_559 + __v_573); + let __v_575: G = (__v_557 + __v_574); + let __v_576: G = (__v_441 + __v_575); + let __v_577: G = G::from_u64(256); + let __v_578: G = (__v_577 * __v_450); + let __v_579: G = G::from_u64(65536); + let __v_580: G = (__v_579 * __v_451); + let __v_581: G = G::from_u64(16777216); + let __v_582: G = (__v_581 * __v_452); + let __v_583: G = G::from_u64(4294967296); + let __v_584: G = (__v_583 * __v_453); + let __v_585: G = G::from_u64(1099511627776); + let __v_586: G = (__v_585 * __v_454); + let __v_587: G = G::from_u64(281474976710656); + let __v_588: G = (__v_587 * __v_455); + let __v_589: G = G::from_u64(72057594037927936); + let __v_590: G = (__v_589 * __v_456); + let __v_591: G = (__v_588 + __v_590); + let __v_592: G = (__v_586 + __v_591); + let __v_593: G = (__v_584 + __v_592); + let __v_594: G = (__v_582 + __v_593); + let __v_595: G = (__v_580 + __v_594); + let __v_596: G = (__v_578 + __v_595); + let __v_597: G = (__v_449 + __v_596); + let __v_598: G = G::from_u64(256); + let __v_599: G = (__v_598 * __v_475); + let __v_600: G = G::from_u64(65536); + let __v_601: G = (__v_600 * __v_476); + let __v_602: G = G::from_u64(16777216); + let __v_603: G = (__v_602 * __v_477); + let __v_604: G = G::from_u64(4294967296); + let __v_605: G = (__v_604 * __v_478); + let __v_606: G = G::from_u64(1099511627776); + let __v_607: G = (__v_606 * __v_479); + let __v_608: G = G::from_u64(281474976710656); + let __v_609: G = (__v_608 * __v_480); + let __v_610: G = G::from_u64(72057594037927936); + let __v_611: G = (__v_610 * __v_481); + let __v_612: G = (__v_609 + __v_611); + let __v_613: G = (__v_607 + __v_612); + let __v_614: G = (__v_605 + __v_613); + let __v_615: G = (__v_603 + __v_614); + let __v_616: G = (__v_601 + __v_615); + let __v_617: G = (__v_599 + __v_616); + let __v_618: G = (__v_474 + __v_617); + let __v_619: G = G::from_u64(256); + let __v_620: G = (__v_619 * __v_483); + let __v_621: G = G::from_u64(65536); + let __v_622: G = (__v_621 * __v_484); + let __v_623: G = G::from_u64(16777216); + let __v_624: G = (__v_623 * __v_485); + let __v_625: G = G::from_u64(4294967296); + let __v_626: G = (__v_625 * __v_486); + let __v_627: G = G::from_u64(1099511627776); + let __v_628: G = (__v_627 * __v_487); + let __v_629: G = G::from_u64(281474976710656); + let __v_630: G = (__v_629 * __v_488); + let __v_631: G = G::from_u64(72057594037927936); + let __v_632: G = (__v_631 * __v_489); + let __v_633: G = (__v_630 + __v_632); + let __v_634: G = (__v_628 + __v_633); + let __v_635: G = (__v_626 + __v_634); + let __v_636: G = (__v_624 + __v_635); + let __v_637: G = (__v_622 + __v_636); + let __v_638: G = (__v_620 + __v_637); + let __v_639: G = (__v_482 + __v_638); + let __v_640: G = G::from_u64(256); + let __v_641: G = (__v_640 * __v_497); + let __v_642: G = G::from_u64(65536); + let __v_643: G = (__v_642 * __v_498); + let __v_644: G = G::from_u64(16777216); + let __v_645: G = (__v_644 * __v_499); + let __v_646: G = G::from_u64(4294967296); + let __v_647: G = (__v_646 * __v_500); + let __v_648: G = G::from_u64(1099511627776); + let __v_649: G = (__v_648 * __v_501); + let __v_650: G = G::from_u64(281474976710656); + let __v_651: G = (__v_650 * __v_502); + let __v_652: G = G::from_u64(72057594037927936); + let __v_653: G = (__v_652 * __v_503); + let __v_654: G = (__v_651 + __v_653); + let __v_655: G = (__v_649 + __v_654); + let __v_656: G = (__v_647 + __v_655); + let __v_657: G = (__v_645 + __v_656); + let __v_658: G = (__v_643 + __v_657); + let __v_659: G = (__v_641 + __v_658); + let __v_660: G = (__v_496 + __v_659); + let __v_661: G = G::from_u64(256); + let __v_662: G = (__v_661 * __v_505); + let __v_663: G = G::from_u64(65536); + let __v_664: G = (__v_663 * __v_506); + let __v_665: G = G::from_u64(16777216); + let __v_666: G = (__v_665 * __v_507); + let __v_667: G = G::from_u64(4294967296); + let __v_668: G = (__v_667 * __v_508); + let __v_669: G = G::from_u64(1099511627776); + let __v_670: G = (__v_669 * __v_509); + let __v_671: G = G::from_u64(281474976710656); + let __v_672: G = (__v_671 * __v_510); + let __v_673: G = G::from_u64(72057594037927936); + let __v_674: G = (__v_673 * __v_511); + let __v_675: G = (__v_672 + __v_674); + let __v_676: G = (__v_670 + __v_675); + let __v_677: G = (__v_668 + __v_676); + let __v_678: G = (__v_666 + __v_677); + let __v_679: G = (__v_664 + __v_678); + let __v_680: G = (__v_662 + __v_679); + let __v_681: G = (__v_504 + __v_680); 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_683: G = G::from_u64(0); + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_682, __v_683, __v_358, __v_534, __v_555, __v_576, __v_597]; 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_684: G = __r_arr[0]; + let __v_685: G = __r_arr[1]; + let __v_686: G = G::from_u64(0); + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_361, __v_362, __v_34, __v_30, __v_66, __v_68, __v_63, __v_64, __v_61, __v_686, __v_684, __v_685, __v_534, __v_555, __v_576, __v_597, __v_618, __v_639, __v_660, __v_681]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __v_687: G = __r_arr[0]; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_361]; 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_688: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_685: G = __r_arr[0]; - let __v_686: G = G::from_u64(1); - let __v_687: G = G::from_u64(1); - let __v_688: G = { let __values: [G; 3] = [__v_686, __v_687, __v_687]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_59.as_canonical_u64() { + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_38]; 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_689: G = __r_arr[0]; + let __v_690: G = G::from_u64(1); + let __v_691: G = G::from_u64(1); + let __v_692: G = { let __values: [G; 3] = [__v_690, __v_691, __v_691]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_63.as_canonical_u64() { 0u64 => { - break '__mc_3 [__v_688]; + break '__mc_3 [__v_692]; }, 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_122] = { let __args: [G; IN_122] = [__v_64, __v_692]; 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_693: G = __r_arr[0]; + break '__mc_3 [__v_693]; }, _ => { - return Err(ExecError::MatchNoCase(__v_59.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64())); }, } }; - let __v_689: G = __mc_out___mc_3[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_57, __v_689]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_690: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_64, __v_690]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_691: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_62, __v_691]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_692: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_508, __v_692]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; - let __v_693: G = __r_arr[0]; - let __v_694: G = G::from_u64(1); - let __v_695: G = G::from_u64(1); - let __v_696: G = { let __values: [G; 3] = [__v_694, __v_695, __v_695]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_693, __v_696]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_693: G = __mc_out___mc_3[0]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_61, __v_693]; 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_694: G = __r_arr[0]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_68, __v_694]; 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_695: G = __r_arr[0]; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_66, __v_695]; 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_696: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_512, __v_696]; 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_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_698: G = G::from_u64(1); + let __v_699: G = G::from_u64(1); + let __v_700: G = { let __values: [G; 3] = [__v_698, __v_699, __v_699]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_697, __v_700]; 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_701: G = __r_arr[0]; + let __v_702: G = __r_arr[1]; + let __v_703: G = __r_arr[2]; + let __v_704: G = __r_arr[3]; + let __v_705: G = __r_arr[4]; + let __v_706: G = __r_arr[5]; + let __v_707: G = __r_arr[6]; + let __v_708: G = __r_arr[7]; + let __v_709: G = __r_arr[8]; + let __v_710: G = __r_arr[9]; + let __v_711: G = __r_arr[10]; + let __v_712: G = __r_arr[11]; + let __v_713: G = __r_arr[12]; + let __v_714: G = __r_arr[13]; + let __v_715: G = __r_arr[14]; + let __v_716: G = __r_arr[15]; + let __v_717: G = __r_arr[16]; + let __v_718: G = __r_arr[17]; + let __v_719: G = G::from_u64(256); + let __v_720: G = (__v_719 * __v_702); + let __v_721: G = G::from_u64(65536); + let __v_722: G = (__v_721 * __v_703); + let __v_723: G = G::from_u64(16777216); + let __v_724: G = (__v_723 * __v_704); + let __v_725: G = G::from_u64(4294967296); + let __v_726: G = (__v_725 * __v_705); + let __v_727: G = G::from_u64(1099511627776); + let __v_728: G = (__v_727 * __v_706); + let __v_729: G = G::from_u64(281474976710656); + let __v_730: G = (__v_729 * __v_707); + let __v_731: G = G::from_u64(72057594037927936); + let __v_732: G = (__v_731 * __v_708); + let __v_733: G = (__v_730 + __v_732); + let __v_734: G = (__v_728 + __v_733); + let __v_735: G = (__v_726 + __v_734); + let __v_736: G = (__v_724 + __v_735); + let __v_737: G = (__v_722 + __v_736); + let __v_738: G = (__v_720 + __v_737); + let __v_739: G = (__v_701 + __v_738); + let __v_740: G = G::from_u64(256); + let __v_741: G = (__v_740 * __v_710); + let __v_742: G = G::from_u64(65536); + let __v_743: G = (__v_742 * __v_711); + let __v_744: G = G::from_u64(16777216); + let __v_745: G = (__v_744 * __v_712); + let __v_746: G = G::from_u64(4294967296); + let __v_747: G = (__v_746 * __v_713); + let __v_748: G = G::from_u64(1099511627776); + let __v_749: G = (__v_748 * __v_714); + let __v_750: G = G::from_u64(281474976710656); + let __v_751: G = (__v_750 * __v_715); + let __v_752: G = G::from_u64(72057594037927936); + let __v_753: G = (__v_752 * __v_716); + let __v_754: G = (__v_751 + __v_753); + let __v_755: G = (__v_749 + __v_754); + let __v_756: G = (__v_747 + __v_755); + let __v_757: G = (__v_745 + __v_756); + let __v_758: G = (__v_743 + __v_757); + let __v_759: G = (__v_741 + __v_758); + let __v_760: G = (__v_709 + __v_759); + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_717, __v_38, __v_40, __v_209]; 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_761: G = __r_arr[0]; + let __v_762: G = __r_arr[1]; + let __v_763: G = G::from_u64(1); + let __v_764: G = G::from_u64(1); + let __v_765: G = { let __values: [G; 3] = [__v_763, __v_764, __v_764]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_50, __v_765]; 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_766: G = __r_arr[0]; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_762, __v_766]; 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_767: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_767, __v_38]; 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_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 __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_768, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_219]; 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_769: G = __r_arr[0]; + let __v_770: G = __r_arr[1]; + let __v_771: G = (__v_689 + __v_159); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_769, __v_770, __v_199, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_772: G = __r_arr[0]; + let __v_773: G = G::from_u64(0); + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_44, __v_48, __v_773, __v_199]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_774: G = __r_arr[0]; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_769, __v_770, __v_774, __v_739, __v_760, __v_66, __v_68, __v_61, __v_63, __v_64, __v_24, __v_26, __v_28, __v_363, __v_362, __v_34, __v_660, __v_681, __v_688, __v_159, __v_771, __v_761, __v_38, __v_50, __v_689]; 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_775: G = __r_arr[0]; + let __v_776: G = G::from_u64(0); + if (__v_169 != __v_776) { + return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_776.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 __v_777: G = G::from_u64(0); + if (__v_179 != __v_777) { + return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_777.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 __v_778: G = G::from_u64(1); + if (__v_189 != __v_778) { + return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_778.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_22]; 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_779: G = __r_arr[0]; + let __v_780: G = G::from_u64(1); + if (__v_779 != __v_780) { + return Err(ExecError::AssertEqMismatch { lhs: __v_779.as_canonical_u64(), rhs: __v_780.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_22]; 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_781: G = __r_arr[0]; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_256]; 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_782: G = __r_arr[0]; + let __v_783: G = (__v_781 - __v_782); + let __v_784: G = G::from_bool((__v_783 == G::ZERO)); + let __v_785: G = G::from_u64(1); + if (__v_784 != __v_785) { + return Err(ExecError::AssertEqMismatch { lhs: __v_784.as_canonical_u64(), rhs: __v_785.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_217] = { let __args: [G; IN_217] = [__v_361]; 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_786: G = __r_arr[0]; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_30]; 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_787: G = __r_arr[0]; + let __v_788: G = (__v_786 - __v_787); + let __v_789: G = G::from_bool((__v_788 == G::ZERO)); + let __v_790: G = G::from_u64(1); + if (__v_789 != __v_790) { + return Err(ExecError::AssertEqMismatch { lhs: __v_789.as_canonical_u64(), rhs: __v_790.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_210] = { let __args: [G; IN_210] = [__v_40]; 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 __v_791: G = __r_arr[0]; + let __v_792: G = (__v_791 - __v_689); + let __v_793: G = G::from_bool((__v_792 == G::ZERO)); + let __v_794: G = G::from_u64(1); + if (__v_793 != __v_794) { + return Err(ExecError::AssertEqMismatch { lhs: __v_793.as_canonical_u64(), rhs: __v_794.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_206] = { let __args: [G; IN_206] = [__v_44]; 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_795: G = __r_arr[0]; + let __v_796: G = G::from_u64(3); + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_63, __v_64]; 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_797: G = __r_arr[0]; + let __v_798: G = (__v_796 + __v_797); + if (__v_795 != __v_798) { + return Err(ExecError::AssertEqMismatch { lhs: __v_795.as_canonical_u64(), rhs: __v_798.as_canonical_u64(), msg: None }); } - let __v_790: G = G::from_u64(33); - let __v_791: G = { let __a_val = __v_767.as_canonical_u64(); let __b_val = __v_790.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __v_792: G = G::from_u64(1); - if (__v_791 != __v_792) { - return Err(ExecError::AssertEqMismatch { lhs: __v_791.as_canonical_u64(), rhs: __v_792.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_48]; 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_799: G = __r_arr[0]; + let __v_800: G = (__v_799 - __v_689); + let __v_801: G = G::from_bool((__v_800 == G::ZERO)); + let __v_802: G = G::from_u64(1); + if (__v_801 != __v_802) { + return Err(ExecError::AssertEqMismatch { lhs: __v_801.as_canonical_u64(), rhs: __v_802.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_206] = { let __args: [G; IN_206] = [__v_50]; 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_803: G = __r_arr[0]; + let __v_804: G = G::from_u64(1); + if (__v_803 != __v_804) { + return Err(ExecError::AssertEqMismatch { lhs: __v_803.as_canonical_u64(), rhs: __v_804.as_canonical_u64(), msg: None }); + } + let __v_805: G = G::from_u64(33); + let __v_806: G = { let __a_val = __v_771.as_canonical_u64(); let __b_val = __v_805.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_807: G = G::from_u64(1); + if (__v_806 != __v_807) { + return Err(ExecError::AssertEqMismatch { lhs: __v_806.as_canonical_u64(), rhs: __v_807.as_canonical_u64(), msg: None }); + } + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_44, __v_772, __v_24, __v_26, __v_28, __v_363, __v_63, __v_64, __v_362, __v_34, __v_688, __v_159, __v_771]; 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_808: G = __r_arr[0]; + let __v_809: G = G::from_u64(1); + if (__v_808 != __v_809) { + return Err(ExecError::AssertEqMismatch { lhs: __v_808.as_canonical_u64(), rhs: __v_809.as_canonical_u64(), msg: None }); + } + let __v_810: G = G::from_u64(0); + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_48, __v_38, __v_775, __v_772, __v_810, __v_771]; 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_811: G = __r_arr[0]; + break '__mc_1 [__v_811]; }, } }, @@ -19184,260 +20142,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_361: G = __mc_out___mc_1[0]; + let __v_362: G = (__v_18 + __v_19); + if (__v_69 != __v_362) { + return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_362.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 }); + let __v_363: G = G::from_u64(256); + let __v_364: G = (__v_363 * __v_128); + let __v_365: G = G::from_u64(65536); + let __v_366: G = (__v_365 * __v_129); + let __v_367: G = G::from_u64(16777216); + let __v_368: G = (__v_367 * __v_130); + let __v_369: G = (__v_366 + __v_368); + let __v_370: G = (__v_364 + __v_369); + let __v_371: G = (__v_127 + __v_370); + let __v_372: G = G::from_u64(256); + let __v_373: G = (__v_372 * __v_132); + let __v_374: G = G::from_u64(65536); + let __v_375: G = (__v_374 * __v_133); + let __v_376: G = G::from_u64(16777216); + let __v_377: G = (__v_376 * __v_134); + let __v_378: G = (__v_375 + __v_377); + let __v_379: G = (__v_373 + __v_378); + let __v_380: G = (__v_131 + __v_379); + let __v_381: G = G::from_u64(256); + let __v_382: G = (__v_381 * __v_136); + let __v_383: G = G::from_u64(65536); + let __v_384: G = (__v_383 * __v_137); + let __v_385: G = G::from_u64(16777216); + let __v_386: G = (__v_385 * __v_138); + let __v_387: G = (__v_384 + __v_386); + let __v_388: G = (__v_382 + __v_387); + let __v_389: G = (__v_135 + __v_388); + let __v_390: G = G::from_u64(256); + let __v_391: G = (__v_390 * __v_140); + let __v_392: G = G::from_u64(65536); + let __v_393: G = (__v_392 * __v_141); + let __v_394: G = G::from_u64(16777216); + let __v_395: G = (__v_394 * __v_142); + let __v_396: G = (__v_393 + __v_395); + let __v_397: G = (__v_391 + __v_396); + let __v_398: G = (__v_139 + __v_397); + let __v_399: G = G::from_u64(256); + let __v_400: G = (__v_399 * __v_144); + let __v_401: G = G::from_u64(65536); + let __v_402: G = (__v_401 * __v_145); + let __v_403: G = G::from_u64(16777216); + let __v_404: G = (__v_403 * __v_146); + let __v_405: G = (__v_402 + __v_404); + let __v_406: G = (__v_400 + __v_405); + let __v_407: G = (__v_143 + __v_406); + let __v_408: G = G::from_u64(256); + let __v_409: G = (__v_408 * __v_148); + let __v_410: G = G::from_u64(65536); + let __v_411: G = (__v_410 * __v_149); + let __v_412: G = G::from_u64(16777216); + let __v_413: G = (__v_412 * __v_150); + let __v_414: G = (__v_411 + __v_413); + let __v_415: G = (__v_409 + __v_414); + let __v_416: G = (__v_147 + __v_415); + let __v_417: G = G::from_u64(256); + let __v_418: G = (__v_417 * __v_152); + let __v_419: G = G::from_u64(65536); + let __v_420: G = (__v_419 * __v_153); + let __v_421: G = G::from_u64(16777216); + let __v_422: G = (__v_421 * __v_154); + let __v_423: G = (__v_420 + __v_422); + let __v_424: G = (__v_418 + __v_423); + let __v_425: G = (__v_151 + __v_424); + let __v_426: G = G::from_u64(256); + let __v_427: G = (__v_426 * __v_156); + let __v_428: G = G::from_u64(65536); + let __v_429: G = (__v_428 * __v_157); + let __v_430: G = G::from_u64(16777216); + let __v_431: G = (__v_430 * __v_158); + let __v_432: G = (__v_429 + __v_431); + let __v_433: G = (__v_427 + __v_432); + let __v_434: G = (__v_155 + __v_433); + if (__v_371 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_371.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_380 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_380.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_389 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_389.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_398 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_398.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_407 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_407.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_416 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_416.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_425 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_425.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 }); + if (__v_434 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_434.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 }); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_263.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_435: G = __loaded[0]; + let __v_436: G = __loaded[1]; + let __v_437: G = __loaded[2]; + let __v_438: G = G::from_u64(1); + let __v_439: G = G::from_u64(1); + if (__v_435 != __v_438) { + return Err(ExecError::AssertEqMismatch { lhs: __v_435.as_canonical_u64(), rhs: __v_438.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_436 != __v_439) { + return Err(ExecError::AssertEqMismatch { lhs: __v_436.as_canonical_u64(), rhs: __v_439.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 }); + if (__v_437 != __v_439) { + return Err(ExecError::AssertEqMismatch { lhs: __v_437.as_canonical_u64(), rhs: __v_439.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 }); + let __v_440: G = G::from_u64(256); + let __v_441: G = (__v_440 * __v_325); + let __v_442: G = G::from_u64(65536); + let __v_443: G = (__v_442 * __v_326); + let __v_444: G = G::from_u64(16777216); + let __v_445: G = (__v_444 * __v_327); + let __v_446: G = (__v_443 + __v_445); + let __v_447: G = (__v_441 + __v_446); + let __v_448: G = (__v_324 + __v_447); + let __v_449: G = G::from_u64(256); + let __v_450: G = (__v_449 * __v_329); + let __v_451: G = G::from_u64(65536); + let __v_452: G = (__v_451 * __v_330); + let __v_453: G = G::from_u64(16777216); + let __v_454: G = (__v_453 * __v_331); + let __v_455: G = (__v_452 + __v_454); + let __v_456: G = (__v_450 + __v_455); + let __v_457: G = (__v_328 + __v_456); + let __v_458: G = G::from_u64(256); + let __v_459: G = (__v_458 * __v_333); + let __v_460: G = G::from_u64(65536); + let __v_461: G = (__v_460 * __v_334); + let __v_462: G = G::from_u64(16777216); + let __v_463: G = (__v_462 * __v_335); + let __v_464: G = (__v_461 + __v_463); + let __v_465: G = (__v_459 + __v_464); + let __v_466: G = (__v_332 + __v_465); + let __v_467: G = G::from_u64(256); + let __v_468: G = (__v_467 * __v_337); + let __v_469: G = G::from_u64(65536); + let __v_470: G = (__v_469 * __v_338); + let __v_471: G = G::from_u64(16777216); + let __v_472: G = (__v_471 * __v_339); + let __v_473: G = (__v_470 + __v_472); + let __v_474: G = (__v_468 + __v_473); + let __v_475: G = (__v_336 + __v_474); + let __v_476: G = G::from_u64(256); + let __v_477: G = (__v_476 * __v_341); + let __v_478: G = G::from_u64(65536); + let __v_479: G = (__v_478 * __v_342); + let __v_480: G = G::from_u64(16777216); + let __v_481: G = (__v_480 * __v_343); + let __v_482: G = (__v_479 + __v_481); + let __v_483: G = (__v_477 + __v_482); + let __v_484: G = (__v_340 + __v_483); + let __v_485: G = G::from_u64(256); + let __v_486: G = (__v_485 * __v_345); + let __v_487: G = G::from_u64(65536); + let __v_488: G = (__v_487 * __v_346); + let __v_489: G = G::from_u64(16777216); + let __v_490: G = (__v_489 * __v_347); + let __v_491: G = (__v_488 + __v_490); + let __v_492: G = (__v_486 + __v_491); + let __v_493: G = (__v_344 + __v_492); + let __v_494: G = G::from_u64(256); + let __v_495: G = (__v_494 * __v_349); + let __v_496: G = G::from_u64(65536); + let __v_497: G = (__v_496 * __v_350); + let __v_498: G = G::from_u64(16777216); + let __v_499: G = (__v_498 * __v_351); + let __v_500: G = (__v_497 + __v_499); + let __v_501: G = (__v_495 + __v_500); + let __v_502: G = (__v_348 + __v_501); + let __v_503: G = G::from_u64(256); + let __v_504: G = (__v_503 * __v_353); + let __v_505: G = G::from_u64(65536); + let __v_506: G = (__v_505 * __v_354); + let __v_507: G = G::from_u64(16777216); + let __v_508: G = (__v_507 * __v_355); + let __v_509: G = (__v_506 + __v_508); + let __v_510: G = (__v_504 + __v_509); + let __v_511: G = (__v_352 + __v_510); + if (__v_448 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_448.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_457 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_457.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_466 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_466.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_475 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_475.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_484 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_484.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_493 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_493.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_502 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_502.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 }); + if (__v_511 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_511.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 }); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_359.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_512: G = __loaded[0]; + let __v_513: G = __loaded[1]; + let __v_514: G = __loaded[2]; + let __v_515: G = G::from_u64(1); + let __v_516: G = G::from_u64(1); + if (__v_512 != __v_515) { + return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_515.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_513 != __v_516) { + return Err(ExecError::AssertEqMismatch { lhs: __v_513.as_canonical_u64(), rhs: __v_516.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 }); + if (__v_514 != __v_516) { + return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_516.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_517: G = G::from_u64(1); + if (__v_360 != __v_517) { + return Err(ExecError::AssertEqMismatch { lhs: __v_360.as_canonical_u64(), rhs: __v_517.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 __v_518: G = G::from_u64(1); + if (__v_361 != __v_518) { + return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_518.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 __ret: [G; OUT_203] = []; + 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); }) } -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_204: usize = 2; +const IN_204: usize = 2; +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_192], ExecError> { +) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_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_216] = { let __args: [G; IN_216] = [__v_0, __v_1]; 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_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 +20403,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_204] = [__v_4]; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19456,15 +20414,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_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_193], ExecError> { +) -> 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 }; @@ -19473,87 +20431,18 @@ fn aiur_fn_193( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_193] = [__v_4]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - 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)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_194: usize = 2; -const IN_194: usize = 2; -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 __v_1: G = inp[1]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; - let __v_2: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; - let __v_3: G = __loaded[0]; - let __v_4: G = __loaded[1]; - let __v_5: G = __loaded[2]; - let __v_6: G = __loaded[3]; - match __v_3.as_canonical_u64() { - 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)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_195: usize = 1; -const IN_195: usize = 1; -const OUT_195: usize = 1; -fn aiur_fn_195( - inp: [G; IN_195], - 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 __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_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_205] = [__v_4]; + 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); }, 0u64 => { - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = G::from_u64(1); - let __v_8: G = (__v_6 + __v_7); - let __ret: [G; OUT_195] = [__v_8]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__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 __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_205] = [__v_6]; + 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); }, _ => { @@ -19563,15 +20452,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_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_196], ExecError> { +) -> Result<[G; OUT_206], 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 }; @@ -19581,81 +20470,36 @@ fn aiur_fn_196( 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_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)); }; - return Ok(__ret); - }, - 0u64 => { - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __v_6: G = G::from_u64(1); - let __v_7: G = (__v_5 + __v_6); - let __ret: [G; OUT_196] = [__v_7]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); - }, - } - }) -} - -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 __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_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 __v_5: G = G::from_u64(0); + let __ret: [G; OUT_206] = [__v_5]; + 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); }, 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 __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 __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4]; 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_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_206] = [__v_7]; + 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); }, _ => { - return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -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_207: usize = 2; +const IN_207: usize = 2; +const OUT_207: usize = 1; +fn aiur_fn_207( + inp: [G; IN_207], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_198], ExecError> { +) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -19665,17 +20509,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_207] = [__v_1]; + 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); }, 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_207] = { let __args: [G; IN_207] = [__v_4, __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_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_207] = [__v_7]; + 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); }, _ => { @@ -19685,57 +20529,56 @@ 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_208: usize = 1; +const IN_208: usize = 1; +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_199], ExecError> { +) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; match __v_1.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_208] = [__v_7]; + 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 __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 __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_6]; 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_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_7 + __v_8); + let __ret: [G; OUT_208] = [__v_9]; + 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); }, _ => { - 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 __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_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)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); - }, - } + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); }, } }) } -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_209: usize = 1; +const IN_209: usize = 1; +const OUT_209: usize = 1; +fn aiur_fn_209( + inp: [G; IN_209], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_200], ExecError> { +) -> Result<[G; OUT_209], 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 +20592,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_209] = [__v_8]; + 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); }, 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_209] = { let __args: [G; IN_209] = [__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 __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_209] = [__v_10]; + 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); }, _ => { @@ -19769,15 +20612,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_210: usize = 1; +const IN_210: usize = 1; +const OUT_210: usize = 1; +fn aiur_fn_210( + inp: [G; IN_210], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_201], ExecError> { +) -> Result<[G; OUT_210], 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 +20637,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_210] = [__v_11]; + 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 __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_210] = { let __args: [G; IN_210] = [__v_10]; 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 __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_210] = [__v_13]; + 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); }, _ => { @@ -19814,19 +20657,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_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_202], ExecError> { +) -> 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 __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_219] = { let __args: [G; IN_219] = [__v_0, __v_1]; 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_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 +20680,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_211] = [__v_4, __v_5, __v_6, __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); }, _ => { @@ -19848,40 +20691,149 @@ 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_212: usize = 1; +const IN_212: usize = 1; +const OUT_212: usize = 1; +fn aiur_fn_212( + inp: [G; IN_212], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_203], ExecError> { +) -> Result<[G; OUT_212], 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_212] = [__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); + }, + 0u64 => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_212] = [__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); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_213: usize = 2; +const IN_213: usize = 2; +const OUT_213: usize = 2; +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 __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __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_213] = [__v_4, __v_5]; + 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_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_214: usize = 2; +const IN_214: usize = 2; +const OUT_214: usize = 1; +fn aiur_fn_214( + inp: [G; IN_214], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_214], 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_214] = [__v_1]; + 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); + }, + 0u64 => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_11, __v_1]; 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 = { 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_214] = [__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); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_215: usize = 1; +const IN_215: usize = 1; +const OUT_215: usize = 1; +fn aiur_fn_215( + inp: [G; IN_215], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_215], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; let __v_5: G = __loaded[4]; - let __v_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_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 __v_6: G = G::from_u64(0); + let __ret: [G; OUT_215] = [__v_6]; + 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); }, 0u64 => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_9: G = __r_arr[0]; - let __v_10: G = G::from_u64(1); - let __v_11: G = (__v_9 + __v_10); - let __ret: [G; OUT_203] = [__v_11]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_5]; 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_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_215] = [__v_8]; + 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); }, _ => { @@ -19891,35 +20843,82 @@ 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_216: usize = 2; +const IN_216: usize = 2; +const OUT_216: usize = 1; +fn aiur_fn_216( + inp: [G; IN_216], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_204], ExecError> { +) -> Result<[G; OUT_216], 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 = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_216] = [__v_0]; + 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 __v_2: G = G::from_u64(1); + let __v_3: G = (__v_1 - __v_2); + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __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 __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_216] = [__v_7]; + 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_5.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_217: usize = 1; +const IN_217: usize = 1; +const OUT_217: usize = 1; +fn aiur_fn_217( + inp: [G; IN_217], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_217], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __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_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 __v_9: G = G::from_u64(0); + let __ret: [G; OUT_217] = [__v_9]; + 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); }, 0u64 => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; - let __v_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 __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_8]; 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_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_217] = [__v_11]; + 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); }, _ => { @@ -19929,28 +20928,28 @@ 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_218: usize = 2; +const IN_218: usize = 2; +const OUT_218: usize = 1; +fn aiur_fn_218( + inp: [G; IN_218], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_205], ExecError> { +) -> Result<[G; OUT_218], 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_218] = [__v_0]; + 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); }, _ => { 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_218] = { let __args: [G; IN_218] = [__v_0, __v_3]; 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_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 +20958,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_218] = [__v_8]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19972,28 +20971,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_219: usize = 2; +const IN_219: usize = 2; +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_206], ExecError> { +) -> 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]; 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_219] = [__v_0]; + 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); }, _ => { 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_219] = { let __args: [G; IN_219] = [__v_0, __v_3]; 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_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 +21003,8 @@ 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_219] = [__v_10]; + 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); }, _ => { @@ -21059,6 +22058,71 @@ 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()); + }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, From bbee830238232cc212f1eeb35c6134a61ddc69b8 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Tue, 1 Sep 2026 22:35:52 +0000 Subject: [PATCH 28/44] Fix multi-stark PR77 merge resolution Use the PR77 lean-ffi and multi-stark pins, remove the stale width-binding and multiplicity-bound protocol fields, and regenerate the recursive and aggregate verifier sources. --- Cargo.lock | 50 +- Cargo.toml | 6 +- Ix/MultiStark/SystemDeserialize.lean | 26 +- Ix/MultiStark/Verifier.lean | 9 +- crates/aiur/src/constraints.rs | 6 +- crates/aiur/src/gadgets/bytes1.rs | 3 - crates/aiur/src/gadgets/bytes2.rs | 13 +- crates/aiur/src/lib.rs | 33 - crates/aiur/src/memory.rs | 6 +- crates/aiur/src/synthesis.rs | 86 +- crates/aiur/src/vk_codec.rs | 22 +- crates/ixvm-codegen/src/aiur_ix_aggr.rs | 214 +- crates/ixvm-codegen/src/aiur_multi_stark.rs | 3824 +++++++++---------- 13 files changed, 1869 insertions(+), 2429 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9f9c6923e..0141466ef 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -190,7 +190,7 @@ checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06" [[package]] name = "bignat" version = "0.1.0" -source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=93c7e52952ae94546be08313f4ff3922984c84d5#93c7e52952ae94546be08313f4ff3922984c84d5" +source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5" dependencies = [ "num-bigint 0.4.6", ] @@ -333,9 +333,9 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" [[package]] name = "chacha20" -version = "0.10.1" +version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d524456ba66e72eb8b115ff89e01e497f8e6d11d78b70b1aa13c0fbd97540a81" +checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" dependencies = [ "cfg-if", "cpufeatures 0.3.0", @@ -1922,7 +1922,7 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" [[package]] name = "lean-ffi" version = "0.1.0" -source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=93c7e52952ae94546be08313f4ff3922984c84d5#93c7e52952ae94546be08313f4ff3922984c84d5" +source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5" dependencies = [ "bignat", "bindgen", @@ -2104,11 +2104,10 @@ dependencies = [ [[package]] name = "multi-stark" version = "0.1.0" -source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=2892243e674f9a0b3aca9004a8d00c79a23beec1#2892243e674f9a0b3aca9004a8d00c79a23beec1" +source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=33b4454aa63b88427b3d3cc09980fe86ddeb7e5f#33b4454aa63b88427b3d3cc09980fe86ddeb7e5f" dependencies = [ "bincode", "itertools 0.14.0", - "num-bigint 0.5.1", "p3-air", "p3-blake3", "p3-challenger", @@ -2537,7 +2536,7 @@ checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" [[package]] name = "p3-air" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-field", "p3-matrix", @@ -2548,7 +2547,7 @@ dependencies = [ [[package]] name = "p3-blake3" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "blake3", "p3-symmetric", @@ -2558,7 +2557,7 @@ dependencies = [ [[package]] name = "p3-challenger" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-field", "p3-maybe-rayon", @@ -2570,9 +2569,10 @@ dependencies = [ [[package]] name = "p3-commit" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "itertools 0.15.0", + "p3-dft", "p3-field", "p3-matrix", "p3-multilinear-util", @@ -2583,7 +2583,7 @@ dependencies = [ [[package]] name = "p3-dft" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "itertools 0.15.0", "p3-field", @@ -2597,7 +2597,7 @@ dependencies = [ [[package]] name = "p3-field" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "itertools 0.15.0", "num-bigint 0.5.1", @@ -2612,7 +2612,7 @@ dependencies = [ [[package]] name = "p3-fri" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "itertools 0.15.0", "p3-challenger", @@ -2633,7 +2633,7 @@ dependencies = [ [[package]] name = "p3-goldilocks" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "num-bigint 0.5.1", "p3-dft", @@ -2652,7 +2652,7 @@ dependencies = [ [[package]] name = "p3-keccak" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-symmetric", "p3-util", @@ -2662,7 +2662,7 @@ dependencies = [ [[package]] name = "p3-matrix" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "itertools 0.15.0", "p3-field", @@ -2676,7 +2676,7 @@ dependencies = [ [[package]] name = "p3-maybe-rayon" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "rayon", ] @@ -2684,7 +2684,7 @@ dependencies = [ [[package]] name = "p3-mds" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-dft", "p3-field", @@ -2696,7 +2696,7 @@ dependencies = [ [[package]] name = "p3-merkle-tree" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "itertools 0.15.0", "p3-commit", @@ -2715,7 +2715,7 @@ dependencies = [ [[package]] name = "p3-multilinear-util" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "itertools 0.15.0", "p3-field", @@ -2730,7 +2730,7 @@ dependencies = [ [[package]] name = "p3-poseidon1" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-field", "p3-mds", @@ -2741,7 +2741,7 @@ dependencies = [ [[package]] name = "p3-poseidon2" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-field", "p3-mds", @@ -2753,7 +2753,7 @@ dependencies = [ [[package]] name = "p3-security" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "libm", "p3-air", @@ -2765,7 +2765,7 @@ dependencies = [ [[package]] name = "p3-symmetric" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "itertools 0.15.0", "p3-field", @@ -2776,7 +2776,7 @@ dependencies = [ [[package]] name = "p3-util" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" +source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" dependencies = [ "p3-maybe-rayon", "serde", diff --git a/Cargo.toml b/Cargo.toml index 0b1ab7f29..70d17d38e 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 = "93c7e52952ae94546be08313f4ff3922984c84d5" } -lean-ffi = { git = "https://github.com/argumentcomputer/lean-ffi.git", rev = "93c7e52952ae94546be08313f4ff3922984c84d5" } +bignat = { git = "https://github.com/argumentcomputer/lean-ffi.git", rev = "2a9c91eba44ea791978a086a6a19b3a922edfee5" } +lean-ffi = { git = "https://github.com/argumentcomputer/lean-ffi.git", rev = "2a9c91eba44ea791978a086a6a19b3a922edfee5" } # 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 = "2892243e674f9a0b3aca9004a8d00c79a23beec1" } +multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "33b4454aa63b88427b3d3cc09980fe86ddeb7e5f" } nom = "7.1.3" num-bigint = "0.4.6" quickcheck = "1.0.3" diff --git a/Ix/MultiStark/SystemDeserialize.lean b/Ix/MultiStark/SystemDeserialize.lean index 7e30323ad..05ff6c915 100644 --- a/Ix/MultiStark/SystemDeserialize.lean +++ b/Ix/MultiStark/SystemDeserialize.lean @@ -43,11 +43,10 @@ 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 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). +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). -/ public section @@ -98,8 +97,7 @@ 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 - -- width-binding policy word, the circuit count, then 7 metadata words per - -- circuit) — kept as limbs because + -- circuit count, then 6 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›) } @@ -318,12 +316,7 @@ def systemDeserialize := ⟦ fn read_sys_lookup(i: ByteStream) -> (SysLookup, ByteStream) { let (m, i1) = read_vk_u16(i); - -- 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 (ac, i2) = read_vk_u16(i1); let (args, i3) = read_node_ids_n(i2, ac); (SysLookup.Mk(m, args), i3) } @@ -457,13 +450,8 @@ 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(wblimb, store(ListNode.Cons(nlimb, climbs))))), + list_concat(plimbs, store(ListNode.Cons(nlimb, climbs))), circuits, commit, indices), j4) } diff --git a/Ix/MultiStark/Verifier.lean b/Ix/MultiStark/Verifier.lean index b6487075b..5e72fd32c 100644 --- a/Ix/MultiStark/Verifier.lean +++ b/Ix/MultiStark/Verifier.lean @@ -308,9 +308,8 @@ 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 (width-binding policy - -- word, circuit count, 7 metadata words per circuit) → preprocessed_commit - -- (if any) → stage_1 → + -- seed = tag + protocol parameters; observe_shape (circuit count + 6 + -- 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 α; @@ -603,9 +602,7 @@ def verifier := ⟦ @eg_add(@eg_mul(a0, b1), @eg_mul(a1, b0))) } - -- fingerprint(γ, args) = Σᵢ argsᵢ·γ^i as a coordinate pair — the plain - -- Horner fold of `WidthBinding::ByConstruction`, the policy aiur declares - -- (and the transcript replay observes): + -- fingerprint(γ, args) = Σᵢ argsᵢ·γ^i as a coordinate pair: -- 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/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs index f4a708cca..26488ce50 100644 --- a/crates/aiur/src/constraints.rs +++ b/crates/aiur/src/constraints.rs @@ -164,10 +164,7 @@ impl Toplevel { } fn empty_lookup() -> Lookup { - // 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 } + Lookup { multiplicity: konst(G::ZERO), args: vec![] } } impl Function { @@ -185,7 +182,6 @@ 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/gadgets/bytes1.rs b/crates/aiur/src/gadgets/bytes1.rs index 4765ca953..e3acd1552 100644 --- a/crates/aiur/src/gadgets/bytes1.rs +++ b/crates/aiur/src/gadgets/bytes1.rs @@ -139,19 +139,16 @@ 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] diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs index e9e03d364..e013a6a34 100644 --- a/crates/aiur/src/gadgets/bytes2.rs +++ b/crates/aiur/src/gadgets/bytes2.rs @@ -211,54 +211,45 @@ impl AiurGadget for Bytes2 { let xor_split4_hi = Expr::preprocessed(12); let xor_split4_lo = Expr::preprocessed(13); - // pull = negated multiplicity; count columns declare the query budget. - let budget = crate::COUNT_COLUMN_BUDGET; + // pull = negated multiplicity. 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 { @@ -270,12 +261,10 @@ 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![ diff --git a/crates/aiur/src/lib.rs b/crates/aiur/src/lib.rs index f915d1e43..3acf6666a 100644 --- a/crates/aiur/src/lib.rs +++ b/crates/aiur/src/lib.rs @@ -15,39 +15,6 @@ use rustc_hash::FxBuildHasher; pub type G = multi_stark::p3_goldilocks::Goldilocks; pub type FxIndexMap = IndexMap; -/// 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 38550a1ee..c3fd487d0 100644 --- a/crates/aiur/src/memory.rs +++ b/crates/aiur/src/memory.rs @@ -46,11 +46,7 @@ impl Memory { } let width = Self::width(size); // pull = negated multiplicity. - let lookups = vec![Lookup { - multiplicity: -multiplicity, - args, - max_multiplicity: crate::COUNT_COLUMN_BUDGET, - }]; + let lookups = vec![Lookup { multiplicity: -multiplicity, args }]; // Transition constraints (formerly the `Air::eval` body): the selector is // boolean; a real next row implies a real current row; and the pointer diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 8d863e301..1bfec2b9d 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -1,6 +1,6 @@ use multi_stark::{ expr::Expr, - lookup::{Lookup, WidthBinding}, + lookup::Lookup, p3_field::PrimeCharacteristicRing, p3_matrix::dense::RowMajorMatrix, prover::Proof, @@ -149,11 +149,7 @@ impl AiurSystem { 2, ); - // 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 config = AiurConfig::new(commitment_parameters, fri_parameters); let (system, key) = System::new(config, circuit_inputs); AiurSystem { system, @@ -831,82 +827,4 @@ 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::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 e19baf198..9fa9e00ec 100644 --- a/crates/aiur/src/vk_codec.rs +++ b/crates/aiur/src/vk_codec.rs @@ -45,7 +45,6 @@ //! 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) @@ -65,7 +64,7 @@ use multi_stark::{ expr::{ColRef, RowOffset, Source}, graph::{ConstraintGraph, Node, NodeId}, - lookup::{Lookup, WidthBinding}, + lookup::Lookup, p3_field::{PrimeCharacteristicRing, PrimeField64}, system::{Circuit, System}, types::{Commitment, CommitmentParameters, FriParameters, Val}, @@ -90,10 +89,6 @@ fn push_u32(buf: &mut Vec, v: usize) { buf.extend_from_slice(&v.to_le_bytes()); } -fn push_u64(buf: &mut Vec, 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, id: NodeId) { @@ -190,7 +185,6 @@ fn encode_circuit(buf: &mut Vec, circuit: &Circuit) { 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); @@ -367,13 +361,12 @@ fn decode_circuit(seg: &mut Seg<'_>) -> Result, 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, max_multiplicity }); + lookups.push(Lookup { multiplicity, args }); } let degrees = recompute_degrees(&nodes); @@ -490,11 +483,7 @@ pub(crate) fn from_bytes( } r.done("vk")?; let system = System { - // 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), + config: AiurConfig::new(commitment_parameters, fri_parameters), circuits, preprocessed_commit, preprocessed_indices, @@ -543,10 +532,7 @@ mod tests { lookup_group_size: 2, }, ]; - let (system, _key) = System::new( - AiurConfig::new(cp, fp).with_width_binding(WidthBinding::ByConstruction), - inputs, - ); + let (system, _key) = System::new(AiurConfig::new(cp, fp), inputs); (system, cp, fp) } diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr.rs b/crates/ixvm-codegen/src/aiur_ix_aggr.rs index 836ecd2e1..0b8730ec4 100644 --- a/crates/ixvm-codegen/src/aiur_ix_aggr.rs +++ b/crates/ixvm-codegen/src/aiur_ix_aggr.rs @@ -8571,23 +8571,13 @@ fn aiur_fn_88( 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 __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 __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]; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4, __v_3]; 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_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __ret: [G; OUT_88] = [__v_1, __v_5, __v_6]; 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); }) @@ -8618,30 +8608,20 @@ fn aiur_fn_89( 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 __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 = __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]; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_5, __v_4]; 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(1); + let __v_9: G = (__v_1 - __v_8); + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_7, __v_9]; 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_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_89] = [__v_13, __v_11]; if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, @@ -9672,70 +9652,11 @@ fn aiur_fn_97( 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_253] = { let __args: [G; IN_253] = [__v_87, __v_155]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; - let __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]; + 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_253] = { let __args: [G; IN_253] = [__v_87, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __v_108: G = __r_arr[0]; + let __ret: [G; OUT_97] = [__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[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); }) @@ -22689,85 +22610,26 @@ fn aiur_fn_236( 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_253] = { let __args: [G; IN_253] = [__v_263, __v_331]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; - let __v_332: G = __r_arr[0]; + let __v_282: G = G::from_u64(0); + let __v_283: G = { let __values: [G; 10] = [__v_282, __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 __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_263, __v_283]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __v_284: 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 }); + let __v_285: G = __loaded[0]; + let __v_286: G = __loaded[1]; + let __v_287: G = __loaded[2]; + let __v_288: G = G::from_u64(1); + let __v_289: G = G::from_u64(1); + if (__v_285 != __v_288) { + return Err(ExecError::AssertEqMismatch { lhs: __v_285.as_canonical_u64(), rhs: __v_288.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_286 != __v_289) { + return Err(ExecError::AssertEqMismatch { lhs: __v_286.as_canonical_u64(), rhs: __v_289.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 }); + if (__v_287 != __v_289) { + return Err(ExecError::AssertEqMismatch { lhs: __v_287.as_canonical_u64(), rhs: __v_289.as_canonical_u64(), msg: None }); } - let __ret: [G; OUT_236] = [__v_177, __v_187, __v_197, __v_207, __v_217, __v_227, __v_237, __v_332, __v_274, __v_277, __v_278, __v_280]; + let __ret: [G; OUT_236] = [__v_177, __v_187, __v_197, __v_207, __v_217, __v_227, __v_237, __v_284, __v_274, __v_277, __v_278, __v_280]; 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); }) diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 5ca1ac8f4..9942ec5ef 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -8571,23 +8571,13 @@ fn aiur_fn_88( 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 __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 __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]; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4, __v_3]; 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_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __ret: [G; OUT_88] = [__v_1, __v_5, __v_6]; 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); }) @@ -8618,30 +8608,20 @@ fn aiur_fn_89( 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 __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 = __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]; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_5, __v_4]; 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(1); + let __v_9: G = (__v_1 - __v_8); + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_7, __v_9]; 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_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_89] = [__v_13, __v_11]; if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, @@ -9672,70 +9652,11 @@ fn aiur_fn_97( 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_252] = { let __args: [G; IN_252] = [__v_87, __v_155]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; - let __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]; + 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_252] = { let __args: [G; IN_252] = [__v_87, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __v_108: G = __r_arr[0]; + let __ret: [G; OUT_97] = [__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[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); }) @@ -23800,515 +23721,456 @@ fn aiur_fn_239( 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_252] = { let __args: [G; IN_252] = [__v_368, __v_436]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; - let __v_437: G = __r_arr[0]; - let __v_438: G = G::from_u64(0); - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_437, __v_379, __v_382, __v_383, __v_385, __v_438]; let __cu = unconstrained; 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_439: G = __r_arr[0]; - let __v_440: G = G::from_u64(1); - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_437, __v_379, __v_382, __v_383, __v_385, __v_440]; let __cu = unconstrained; 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_441: G = __r_arr[0]; - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_439, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; 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_442: G = __r_arr[0]; - let __v_443: G = __r_arr[1]; - let __v_444: G = __r_arr[2]; - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_441, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; 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_445: G = __r_arr[0]; - let __v_446: G = __r_arr[1]; - let __v_447: G = __r_arr[2]; - let __v_448: G = G::from_u64(2); - let __v_449: G = G::from_u64(2); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_449]; let __info = io_buffer.get_info(__v_448, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_450: G = __io_pair.0; - let __v_451: G = __io_pair.1; - let __v_452: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_452, __v_450, __v_451]; let __cu = true; 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 { 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_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_230] = { let __args: [G; IN_230] = [__v_453]; 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_537: G = __r_arr[0]; - let __v_538: G = __r_arr[1]; - let __v_539: G = __r_arr[2]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_442]; let __cu = unconstrained; 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_540: G = __r_arr[0]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_445]; 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_541: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_443, __v_444]; 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_542: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_446, __v_447]; 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_543: G = __r_arr[0]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_537]; 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_544: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_538, __v_539]; 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_545: G = __r_arr[0]; - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_540, __v_541, __v_544]; let __cu = unconstrained; 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_542, __v_543, __v_544, __v_545]; 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_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 __v_387: G = G::from_u64(0); + let __v_388: G = { let __values: [G; 10] = [__v_387, __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 __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_368, __v_388]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __v_389: G = __r_arr[0]; + let __v_390: G = G::from_u64(0); + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_389, __v_379, __v_382, __v_383, __v_385, __v_390]; 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_391: G = __r_arr[0]; + let __v_392: G = G::from_u64(1); + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_389, __v_379, __v_382, __v_383, __v_385, __v_392]; 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_393: G = __r_arr[0]; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_391, __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[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_394: G = __r_arr[0]; + let __v_395: G = __r_arr[1]; + let __v_396: G = __r_arr[2]; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_393, __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[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_397: G = __r_arr[0]; + let __v_398: G = __r_arr[1]; + let __v_399: G = __r_arr[2]; + let __v_400: G = G::from_u64(2); + let __v_401: G = G::from_u64(2); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_401]; let __info = io_buffer.get_info(__v_400, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_402: G = __io_pair.0; + let __v_403: G = __io_pair.1; + let __v_404: G = G::from_u64(2); + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_404, __v_402, __v_403]; let __cu = true; 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 { 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_405: G = __r_arr[0]; + let __v_406: G = G::from_u64(103); + let __v_407: G = G::from_u64(230); + let __v_408: G = G::from_u64(9); + let __v_409: G = G::from_u64(106); + let __v_410: G = G::from_u64(133); + let __v_411: G = G::from_u64(174); + let __v_412: G = G::from_u64(103); + let __v_413: G = G::from_u64(187); + let __v_414: G = G::from_u64(114); + let __v_415: G = G::from_u64(243); + let __v_416: G = G::from_u64(110); + let __v_417: G = G::from_u64(60); + let __v_418: G = G::from_u64(58); + let __v_419: G = G::from_u64(245); + let __v_420: G = G::from_u64(79); + let __v_421: G = G::from_u64(165); + let __v_422: G = G::from_u64(127); + let __v_423: G = G::from_u64(82); + let __v_424: G = G::from_u64(14); + let __v_425: G = G::from_u64(81); + let __v_426: G = G::from_u64(140); + let __v_427: G = G::from_u64(104); + let __v_428: G = G::from_u64(5); + let __v_429: G = G::from_u64(155); + let __v_430: G = G::from_u64(171); + let __v_431: G = G::from_u64(217); + let __v_432: G = G::from_u64(131); + let __v_433: G = G::from_u64(31); + let __v_434: G = G::from_u64(25); + let __v_435: G = G::from_u64(205); + let __v_436: G = G::from_u64(224); + let __v_437: G = G::from_u64(91); + let __v_438: G = G::from_u64(1); + let __v_439: G = G::from_u64(1); + let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_441: G = G::from_u64(0); + let __v_442: G = G::from_u64(0); + let __v_443: G = G::from_u64(0); + let __v_444: G = G::from_u64(0); + let __v_445: G = G::from_u64(0); + let __v_446: G = G::from_u64(0); + let __v_447: G = G::from_u64(0); + let __v_448: G = G::from_u64(0); + let __v_449: G = G::from_u64(0); + let __v_450: G = G::from_u64(0); + let __v_451: G = { let __values: [G; 8] = [__v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_449, __v_450]; 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_452: G = { let __values: [G; 32] = [__v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1); + let __v_454: G = G::from_u64(1); + let __v_455: G = { let __values: [G; 34] = [__v_453, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454]; 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_405, __v_440, __v_441, __v_442, __v_451, __v_452, __v_455]; 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_456: G = __r_arr[0]; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_456]; 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_457: G = __r_arr[0]; + let __v_458: G = __r_arr[1]; + let __v_459: G = __r_arr[2]; + let __v_460: G = __r_arr[3]; + let __v_461: G = __r_arr[4]; + let __v_462: G = __r_arr[5]; + let __v_463: G = __r_arr[6]; + let __v_464: G = __r_arr[7]; + let __v_465: G = __r_arr[8]; + let __v_466: G = __r_arr[9]; + let __v_467: G = __r_arr[10]; + let __v_468: G = __r_arr[11]; + let __v_469: G = __r_arr[12]; + let __v_470: G = __r_arr[13]; + let __v_471: G = __r_arr[14]; + let __v_472: G = __r_arr[15]; + let __v_473: G = __r_arr[16]; + let __v_474: G = __r_arr[17]; + let __v_475: G = __r_arr[18]; + let __v_476: G = __r_arr[19]; + let __v_477: G = __r_arr[20]; + let __v_478: G = __r_arr[21]; + let __v_479: G = __r_arr[22]; + let __v_480: G = __r_arr[23]; + let __v_481: G = __r_arr[24]; + let __v_482: G = __r_arr[25]; + let __v_483: G = __r_arr[26]; + let __v_484: G = __r_arr[27]; + let __v_485: G = __r_arr[28]; + let __v_486: G = __r_arr[29]; + let __v_487: G = __r_arr[30]; + let __v_488: G = __r_arr[31]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_405]; 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_489: G = __r_arr[0]; + let __v_490: G = __r_arr[1]; + let __v_491: G = __r_arr[2]; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_394]; 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_492: G = __r_arr[0]; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_397]; 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_493: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_395, __v_396]; 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_494: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_398, __v_399]; 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_495: G = __r_arr[0]; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_489]; 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_496: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_490, __v_491]; 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_497: G = __r_arr[0]; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_492, __v_493, __v_496]; 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_494, __v_495, __v_496, __v_497]; 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_498: G = G::from_u64(96); + if (__v_19 != __v_498) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_498.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); + } + let __v_499: G = G::from_u64(256); + let __v_500: G = (__v_499 * __v_74); + let __v_501: G = G::from_u64(65536); + let __v_502: G = (__v_501 * __v_75); + let __v_503: G = G::from_u64(16777216); + let __v_504: G = (__v_503 * __v_76); + let __v_505: G = (__v_502 + __v_504); + let __v_506: G = (__v_500 + __v_505); + let __v_507: G = (__v_73 + __v_506); + let __v_508: G = G::from_u64(256); + let __v_509: G = (__v_508 * __v_78); + let __v_510: G = G::from_u64(65536); + let __v_511: G = (__v_510 * __v_79); + let __v_512: G = G::from_u64(16777216); + let __v_513: G = (__v_512 * __v_80); + let __v_514: G = (__v_511 + __v_513); + let __v_515: G = (__v_509 + __v_514); + let __v_516: G = (__v_77 + __v_515); + let __v_517: G = G::from_u64(256); + let __v_518: G = (__v_517 * __v_82); + let __v_519: G = G::from_u64(65536); + let __v_520: G = (__v_519 * __v_83); + let __v_521: G = G::from_u64(16777216); + let __v_522: G = (__v_521 * __v_84); + let __v_523: G = (__v_520 + __v_522); + let __v_524: G = (__v_518 + __v_523); + let __v_525: G = (__v_81 + __v_524); + let __v_526: G = G::from_u64(256); + let __v_527: G = (__v_526 * __v_86); + let __v_528: G = G::from_u64(65536); + let __v_529: G = (__v_528 * __v_87); + let __v_530: G = G::from_u64(16777216); + let __v_531: G = (__v_530 * __v_88); + let __v_532: G = (__v_529 + __v_531); + let __v_533: G = (__v_527 + __v_532); + let __v_534: G = (__v_85 + __v_533); + let __v_535: G = G::from_u64(256); + let __v_536: G = (__v_535 * __v_90); + let __v_537: G = G::from_u64(65536); + let __v_538: G = (__v_537 * __v_91); + let __v_539: G = G::from_u64(16777216); + let __v_540: G = (__v_539 * __v_92); + let __v_541: G = (__v_538 + __v_540); + let __v_542: G = (__v_536 + __v_541); + let __v_543: G = (__v_89 + __v_542); + let __v_544: G = G::from_u64(256); + let __v_545: G = (__v_544 * __v_94); + let __v_546: G = G::from_u64(65536); + let __v_547: G = (__v_546 * __v_95); + let __v_548: G = G::from_u64(16777216); + let __v_549: G = (__v_548 * __v_96); + let __v_550: G = (__v_547 + __v_549); + let __v_551: G = (__v_545 + __v_550); + let __v_552: G = (__v_93 + __v_551); + let __v_553: G = G::from_u64(256); + let __v_554: G = (__v_553 * __v_98); + let __v_555: G = G::from_u64(65536); + let __v_556: G = (__v_555 * __v_99); + let __v_557: G = G::from_u64(16777216); + let __v_558: G = (__v_557 * __v_100); + let __v_559: G = (__v_556 + __v_558); + let __v_560: G = (__v_554 + __v_559); + let __v_561: G = (__v_97 + __v_560); + let __v_562: G = G::from_u64(256); + let __v_563: G = (__v_562 * __v_102); + let __v_564: G = G::from_u64(65536); + let __v_565: G = (__v_564 * __v_103); + let __v_566: G = G::from_u64(16777216); + let __v_567: G = (__v_566 * __v_104); + let __v_568: G = (__v_565 + __v_567); + let __v_569: G = (__v_563 + __v_568); + let __v_570: G = (__v_101 + __v_569); + if (__v_507 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_507.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_516 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_516.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_525 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_525.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_534 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_534.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_543 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_543.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_552 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_552.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_561 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_561.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + if (__v_570 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_570.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 __v_571: G = __loaded[0]; + let __v_572: G = __loaded[1]; + let __v_573: G = __loaded[2]; + let __v_574: G = G::from_u64(1); + let __v_575: G = G::from_u64(1); + if (__v_571 != __v_574) { + return Err(ExecError::AssertEqMismatch { lhs: __v_571.as_canonical_u64(), rhs: __v_574.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); + } + if (__v_572 != __v_575) { + return Err(ExecError::AssertEqMismatch { lhs: __v_572.as_canonical_u64(), rhs: __v_575.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); + } + if (__v_573 != __v_575) { + return Err(ExecError::AssertEqMismatch { lhs: __v_573.as_canonical_u64(), rhs: __v_575.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); + } + let __v_576: G = G::from_u64(256); + let __v_577: G = (__v_576 * __v_251); + let __v_578: G = G::from_u64(65536); + let __v_579: G = (__v_578 * __v_252); + let __v_580: G = G::from_u64(16777216); + let __v_581: G = (__v_580 * __v_253); + let __v_582: G = (__v_579 + __v_581); + let __v_583: G = (__v_577 + __v_582); + let __v_584: G = (__v_250 + __v_583); + let __v_585: G = G::from_u64(256); + let __v_586: G = (__v_585 * __v_255); + let __v_587: G = G::from_u64(65536); + let __v_588: G = (__v_587 * __v_256); + let __v_589: G = G::from_u64(16777216); + let __v_590: G = (__v_589 * __v_257); + let __v_591: G = (__v_588 + __v_590); + let __v_592: G = (__v_586 + __v_591); + let __v_593: G = (__v_254 + __v_592); + let __v_594: G = G::from_u64(256); + let __v_595: G = (__v_594 * __v_259); + let __v_596: G = G::from_u64(65536); + let __v_597: G = (__v_596 * __v_260); + let __v_598: G = G::from_u64(16777216); + let __v_599: G = (__v_598 * __v_261); + let __v_600: G = (__v_597 + __v_599); + let __v_601: G = (__v_595 + __v_600); + let __v_602: G = (__v_258 + __v_601); + let __v_603: G = G::from_u64(256); + let __v_604: G = (__v_603 * __v_263); + let __v_605: G = G::from_u64(65536); + let __v_606: G = (__v_605 * __v_264); + let __v_607: G = G::from_u64(16777216); + let __v_608: G = (__v_607 * __v_265); + let __v_609: G = (__v_606 + __v_608); + let __v_610: G = (__v_604 + __v_609); + let __v_611: G = (__v_262 + __v_610); + let __v_612: G = G::from_u64(256); + let __v_613: G = (__v_612 * __v_267); + let __v_614: G = G::from_u64(65536); + let __v_615: G = (__v_614 * __v_268); + let __v_616: G = G::from_u64(16777216); + let __v_617: G = (__v_616 * __v_269); + let __v_618: G = (__v_615 + __v_617); + let __v_619: G = (__v_613 + __v_618); + let __v_620: G = (__v_266 + __v_619); + let __v_621: G = G::from_u64(256); + let __v_622: G = (__v_621 * __v_271); + let __v_623: G = G::from_u64(65536); + let __v_624: G = (__v_623 * __v_272); + let __v_625: G = G::from_u64(16777216); + let __v_626: G = (__v_625 * __v_273); + let __v_627: G = (__v_624 + __v_626); + let __v_628: G = (__v_622 + __v_627); + let __v_629: G = (__v_270 + __v_628); + let __v_630: G = G::from_u64(256); + let __v_631: G = (__v_630 * __v_275); + let __v_632: G = G::from_u64(65536); + let __v_633: G = (__v_632 * __v_276); + let __v_634: G = G::from_u64(16777216); + let __v_635: G = (__v_634 * __v_277); + let __v_636: G = (__v_633 + __v_635); + let __v_637: G = (__v_631 + __v_636); + let __v_638: G = (__v_274 + __v_637); + let __v_639: G = G::from_u64(256); + let __v_640: G = (__v_639 * __v_279); + let __v_641: G = G::from_u64(65536); + let __v_642: G = (__v_641 * __v_280); + let __v_643: G = G::from_u64(16777216); + let __v_644: G = (__v_643 * __v_281); + let __v_645: G = (__v_642 + __v_644); + let __v_646: G = (__v_640 + __v_645); + let __v_647: G = (__v_278 + __v_646); + if (__v_584 != __v_181) { + return Err(ExecError::AssertEqMismatch { lhs: __v_584.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_593 != __v_182) { + return Err(ExecError::AssertEqMismatch { lhs: __v_593.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_602 != __v_183) { + return Err(ExecError::AssertEqMismatch { lhs: __v_602.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_611 != __v_184) { + return Err(ExecError::AssertEqMismatch { lhs: __v_611.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_620 != __v_185) { + return Err(ExecError::AssertEqMismatch { lhs: __v_620.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_629 != __v_186) { + return Err(ExecError::AssertEqMismatch { lhs: __v_629.as_canonical_u64(), rhs: __v_186.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_638 != __v_187) { + return Err(ExecError::AssertEqMismatch { lhs: __v_638.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_647 != __v_188) { + return Err(ExecError::AssertEqMismatch { lhs: __v_647.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 __v_648: G = __loaded[0]; + let __v_649: G = __loaded[1]; + let __v_650: G = __loaded[2]; + let __v_651: G = G::from_u64(1); + let __v_652: G = G::from_u64(1); + if (__v_648 != __v_651) { + return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_651.as_canonical_u64(), msg: None }); + } + if (__v_649 != __v_652) { + return Err(ExecError::AssertEqMismatch { lhs: __v_649.as_canonical_u64(), rhs: __v_652.as_canonical_u64(), msg: None }); + } + if (__v_650 != __v_652) { + return Err(ExecError::AssertEqMismatch { lhs: __v_650.as_canonical_u64(), rhs: __v_652.as_canonical_u64(), msg: None }); + } + let __v_653: G = G::from_u64(256); + let __v_654: G = (__v_653 * __v_458); + let __v_655: G = G::from_u64(65536); + let __v_656: G = (__v_655 * __v_459); + let __v_657: G = G::from_u64(16777216); + let __v_658: G = (__v_657 * __v_460); + let __v_659: G = (__v_656 + __v_658); + let __v_660: G = (__v_654 + __v_659); + let __v_661: G = (__v_457 + __v_660); + let __v_662: G = G::from_u64(256); + let __v_663: G = (__v_662 * __v_462); + let __v_664: G = G::from_u64(65536); + let __v_665: G = (__v_664 * __v_463); + let __v_666: G = G::from_u64(16777216); + let __v_667: G = (__v_666 * __v_464); + let __v_668: G = (__v_665 + __v_667); + let __v_669: G = (__v_663 + __v_668); + let __v_670: G = (__v_461 + __v_669); + let __v_671: G = G::from_u64(256); + let __v_672: G = (__v_671 * __v_466); + let __v_673: G = G::from_u64(65536); + let __v_674: G = (__v_673 * __v_467); + let __v_675: G = G::from_u64(16777216); + let __v_676: G = (__v_675 * __v_468); + let __v_677: G = (__v_674 + __v_676); + let __v_678: G = (__v_672 + __v_677); + let __v_679: G = (__v_465 + __v_678); + let __v_680: G = G::from_u64(256); + let __v_681: G = (__v_680 * __v_470); + let __v_682: G = G::from_u64(65536); + let __v_683: G = (__v_682 * __v_471); + let __v_684: G = G::from_u64(16777216); + let __v_685: G = (__v_684 * __v_472); + let __v_686: G = (__v_683 + __v_685); + let __v_687: G = (__v_681 + __v_686); + let __v_688: G = (__v_469 + __v_687); + let __v_689: G = G::from_u64(256); + let __v_690: G = (__v_689 * __v_474); + let __v_691: G = G::from_u64(65536); + let __v_692: G = (__v_691 * __v_475); + let __v_693: G = G::from_u64(16777216); + let __v_694: G = (__v_693 * __v_476); + let __v_695: G = (__v_692 + __v_694); + let __v_696: G = (__v_690 + __v_695); + let __v_697: G = (__v_473 + __v_696); + let __v_698: G = G::from_u64(256); + let __v_699: G = (__v_698 * __v_478); + let __v_700: G = G::from_u64(65536); + let __v_701: G = (__v_700 * __v_479); + let __v_702: G = G::from_u64(16777216); + let __v_703: G = (__v_702 * __v_480); + let __v_704: G = (__v_701 + __v_703); + let __v_705: G = (__v_699 + __v_704); + let __v_706: G = (__v_477 + __v_705); + let __v_707: G = G::from_u64(256); + let __v_708: G = (__v_707 * __v_482); + let __v_709: G = G::from_u64(65536); + let __v_710: G = (__v_709 * __v_483); + let __v_711: G = G::from_u64(16777216); + let __v_712: G = (__v_711 * __v_484); + let __v_713: G = (__v_710 + __v_712); + let __v_714: G = (__v_708 + __v_713); + let __v_715: G = (__v_481 + __v_714); + let __v_716: G = G::from_u64(256); + let __v_717: G = (__v_716 * __v_486); + let __v_718: G = G::from_u64(65536); + let __v_719: G = (__v_718 * __v_487); + let __v_720: G = G::from_u64(16777216); + let __v_721: G = (__v_720 * __v_488); + let __v_722: G = (__v_719 + __v_721); + let __v_723: G = (__v_717 + __v_722); + let __v_724: G = (__v_485 + __v_723); + if (__v_661 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_661.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_670 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_670.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_679 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_679.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_688 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_688.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_697 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_697.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_706 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_706.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_715 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_715.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_724 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_724.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); } let __ret: [G; OUT_239] = []; 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)); }; @@ -24772,516 +24634,457 @@ fn aiur_fn_240( 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_252] = { let __args: [G; IN_252] = [__v_368, __v_436]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; - let __v_437: G = __r_arr[0]; - let __v_438: G = G::from_u64(0); - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_437, __v_379, __v_382, __v_383, __v_385, __v_438]; let __cu = unconstrained; 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_439: G = __r_arr[0]; - let __v_440: G = G::from_u64(1); - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_437, __v_379, __v_382, __v_383, __v_385, __v_440]; let __cu = unconstrained; 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_441: G = __r_arr[0]; - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_439, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; 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_442: G = __r_arr[0]; - let __v_443: G = __r_arr[1]; - let __v_444: G = __r_arr[2]; - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_441, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; 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_445: G = __r_arr[0]; - let __v_446: G = __r_arr[1]; - let __v_447: G = __r_arr[2]; - let __v_448: G = G::from_u64(2); - let __v_449: G = G::from_u64(2); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_449]; let __info = io_buffer.get_info(__v_448, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_450: G = __io_pair.0; - let __v_451: G = __io_pair.1; - let __v_452: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_452, __v_450, __v_451]; let __cu = true; 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 { 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_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_230] = { let __args: [G; IN_230] = [__v_453]; 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_537: G = __r_arr[0]; - let __v_538: G = __r_arr[1]; - let __v_539: G = __r_arr[2]; - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_442, __v_445]; let __cu = unconstrained; 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 __v_540: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_443, __v_444]; 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_541: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_446, __v_447]; 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_542: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_538, __v_539]; 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_543: G = __r_arr[0]; - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_541, __v_542, __v_537, __v_543]; let __cu = unconstrained; 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 __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 __v_387: G = G::from_u64(0); + let __v_388: G = { let __values: [G; 10] = [__v_387, __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 __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_368, __v_388]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __v_389: G = __r_arr[0]; + let __v_390: G = G::from_u64(0); + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_389, __v_379, __v_382, __v_383, __v_385, __v_390]; 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_391: G = __r_arr[0]; + let __v_392: G = G::from_u64(1); + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_389, __v_379, __v_382, __v_383, __v_385, __v_392]; 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_393: G = __r_arr[0]; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_391, __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[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_394: G = __r_arr[0]; + let __v_395: G = __r_arr[1]; + let __v_396: G = __r_arr[2]; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_393, __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[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_397: G = __r_arr[0]; + let __v_398: G = __r_arr[1]; + let __v_399: G = __r_arr[2]; + let __v_400: G = G::from_u64(2); + let __v_401: G = G::from_u64(2); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_401]; let __info = io_buffer.get_info(__v_400, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_402: G = __io_pair.0; + let __v_403: G = __io_pair.1; + let __v_404: G = G::from_u64(2); + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_404, __v_402, __v_403]; let __cu = true; 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 { 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_405: G = __r_arr[0]; + let __v_406: G = G::from_u64(103); + let __v_407: G = G::from_u64(230); + let __v_408: G = G::from_u64(9); + let __v_409: G = G::from_u64(106); + let __v_410: G = G::from_u64(133); + let __v_411: G = G::from_u64(174); + let __v_412: G = G::from_u64(103); + let __v_413: G = G::from_u64(187); + let __v_414: G = G::from_u64(114); + let __v_415: G = G::from_u64(243); + let __v_416: G = G::from_u64(110); + let __v_417: G = G::from_u64(60); + let __v_418: G = G::from_u64(58); + let __v_419: G = G::from_u64(245); + let __v_420: G = G::from_u64(79); + let __v_421: G = G::from_u64(165); + let __v_422: G = G::from_u64(127); + let __v_423: G = G::from_u64(82); + let __v_424: G = G::from_u64(14); + let __v_425: G = G::from_u64(81); + let __v_426: G = G::from_u64(140); + let __v_427: G = G::from_u64(104); + let __v_428: G = G::from_u64(5); + let __v_429: G = G::from_u64(155); + let __v_430: G = G::from_u64(171); + let __v_431: G = G::from_u64(217); + let __v_432: G = G::from_u64(131); + let __v_433: G = G::from_u64(31); + let __v_434: G = G::from_u64(25); + let __v_435: G = G::from_u64(205); + let __v_436: G = G::from_u64(224); + let __v_437: G = G::from_u64(91); + let __v_438: G = G::from_u64(1); + let __v_439: G = G::from_u64(1); + let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_441: G = G::from_u64(0); + let __v_442: G = G::from_u64(0); + let __v_443: G = G::from_u64(0); + let __v_444: G = G::from_u64(0); + let __v_445: G = G::from_u64(0); + let __v_446: G = G::from_u64(0); + let __v_447: G = G::from_u64(0); + let __v_448: G = G::from_u64(0); + let __v_449: G = G::from_u64(0); + let __v_450: G = G::from_u64(0); + let __v_451: G = { let __values: [G; 8] = [__v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_449, __v_450]; 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_452: G = { let __values: [G; 32] = [__v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1); + let __v_454: G = G::from_u64(1); + let __v_455: G = { let __values: [G; 34] = [__v_453, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454]; 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_405, __v_440, __v_441, __v_442, __v_451, __v_452, __v_455]; 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_456: G = __r_arr[0]; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_456]; 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_457: G = __r_arr[0]; + let __v_458: G = __r_arr[1]; + let __v_459: G = __r_arr[2]; + let __v_460: G = __r_arr[3]; + let __v_461: G = __r_arr[4]; + let __v_462: G = __r_arr[5]; + let __v_463: G = __r_arr[6]; + let __v_464: G = __r_arr[7]; + let __v_465: G = __r_arr[8]; + let __v_466: G = __r_arr[9]; + let __v_467: G = __r_arr[10]; + let __v_468: G = __r_arr[11]; + let __v_469: G = __r_arr[12]; + let __v_470: G = __r_arr[13]; + let __v_471: G = __r_arr[14]; + let __v_472: G = __r_arr[15]; + let __v_473: G = __r_arr[16]; + let __v_474: G = __r_arr[17]; + let __v_475: G = __r_arr[18]; + let __v_476: G = __r_arr[19]; + let __v_477: G = __r_arr[20]; + let __v_478: G = __r_arr[21]; + let __v_479: G = __r_arr[22]; + let __v_480: G = __r_arr[23]; + let __v_481: G = __r_arr[24]; + let __v_482: G = __r_arr[25]; + let __v_483: G = __r_arr[26]; + let __v_484: G = __r_arr[27]; + let __v_485: G = __r_arr[28]; + let __v_486: G = __r_arr[29]; + let __v_487: G = __r_arr[30]; + let __v_488: G = __r_arr[31]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_405]; 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_489: G = __r_arr[0]; + let __v_490: G = __r_arr[1]; + let __v_491: G = __r_arr[2]; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_394, __v_397]; 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 __v_492: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_395, __v_396]; 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_493: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_398, __v_399]; 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_494: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_490, __v_491]; 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_495: G = __r_arr[0]; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_493, __v_494, __v_489, __v_495]; 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 __v_496: G = G::from_u64(96); + if (__v_19 != __v_496) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_496.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); + } + let __v_497: G = G::from_u64(256); + let __v_498: G = (__v_497 * __v_74); + let __v_499: G = G::from_u64(65536); + let __v_500: G = (__v_499 * __v_75); + let __v_501: G = G::from_u64(16777216); + let __v_502: G = (__v_501 * __v_76); + let __v_503: G = (__v_500 + __v_502); + let __v_504: G = (__v_498 + __v_503); + let __v_505: G = (__v_73 + __v_504); + let __v_506: G = G::from_u64(256); + let __v_507: G = (__v_506 * __v_78); + let __v_508: G = G::from_u64(65536); + let __v_509: G = (__v_508 * __v_79); + let __v_510: G = G::from_u64(16777216); + let __v_511: G = (__v_510 * __v_80); + let __v_512: G = (__v_509 + __v_511); + let __v_513: G = (__v_507 + __v_512); + let __v_514: G = (__v_77 + __v_513); + let __v_515: G = G::from_u64(256); + let __v_516: G = (__v_515 * __v_82); + let __v_517: G = G::from_u64(65536); + let __v_518: G = (__v_517 * __v_83); + let __v_519: G = G::from_u64(16777216); + let __v_520: G = (__v_519 * __v_84); + let __v_521: G = (__v_518 + __v_520); + let __v_522: G = (__v_516 + __v_521); + let __v_523: G = (__v_81 + __v_522); + let __v_524: G = G::from_u64(256); + let __v_525: G = (__v_524 * __v_86); + let __v_526: G = G::from_u64(65536); + let __v_527: G = (__v_526 * __v_87); + let __v_528: G = G::from_u64(16777216); + let __v_529: G = (__v_528 * __v_88); + let __v_530: G = (__v_527 + __v_529); + let __v_531: G = (__v_525 + __v_530); + let __v_532: G = (__v_85 + __v_531); + let __v_533: G = G::from_u64(256); + let __v_534: G = (__v_533 * __v_90); + let __v_535: G = G::from_u64(65536); + let __v_536: G = (__v_535 * __v_91); + let __v_537: G = G::from_u64(16777216); + let __v_538: G = (__v_537 * __v_92); + let __v_539: G = (__v_536 + __v_538); + let __v_540: G = (__v_534 + __v_539); + let __v_541: G = (__v_89 + __v_540); + let __v_542: G = G::from_u64(256); + let __v_543: G = (__v_542 * __v_94); + let __v_544: G = G::from_u64(65536); + let __v_545: G = (__v_544 * __v_95); + let __v_546: G = G::from_u64(16777216); + let __v_547: G = (__v_546 * __v_96); + let __v_548: G = (__v_545 + __v_547); + let __v_549: G = (__v_543 + __v_548); + let __v_550: G = (__v_93 + __v_549); + let __v_551: G = G::from_u64(256); + let __v_552: G = (__v_551 * __v_98); + let __v_553: G = G::from_u64(65536); + let __v_554: G = (__v_553 * __v_99); + let __v_555: G = G::from_u64(16777216); + let __v_556: G = (__v_555 * __v_100); + let __v_557: G = (__v_554 + __v_556); + let __v_558: G = (__v_552 + __v_557); + let __v_559: G = (__v_97 + __v_558); + let __v_560: G = G::from_u64(256); + let __v_561: G = (__v_560 * __v_102); + let __v_562: G = G::from_u64(65536); + let __v_563: G = (__v_562 * __v_103); + let __v_564: G = G::from_u64(16777216); + let __v_565: G = (__v_564 * __v_104); + let __v_566: G = (__v_563 + __v_565); + let __v_567: G = (__v_561 + __v_566); + let __v_568: G = (__v_101 + __v_567); + if (__v_505 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_505.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_514 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_523 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_532 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_532.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_541 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_541.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_550 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_550.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_559 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_559.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_568 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_568.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 __v_569: G = __loaded[0]; + let __v_570: G = __loaded[1]; + let __v_571: G = __loaded[2]; + let __v_572: G = G::from_u64(1); + let __v_573: G = G::from_u64(1); + if (__v_569 != __v_572) { + return Err(ExecError::AssertEqMismatch { lhs: __v_569.as_canonical_u64(), rhs: __v_572.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); + } + if (__v_570 != __v_573) { + return Err(ExecError::AssertEqMismatch { lhs: __v_570.as_canonical_u64(), rhs: __v_573.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); + } + if (__v_571 != __v_573) { + return Err(ExecError::AssertEqMismatch { lhs: __v_571.as_canonical_u64(), rhs: __v_573.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); + } + let __v_574: G = G::from_u64(256); + let __v_575: G = (__v_574 * __v_251); + let __v_576: G = G::from_u64(65536); + let __v_577: G = (__v_576 * __v_252); + let __v_578: G = G::from_u64(16777216); + let __v_579: G = (__v_578 * __v_253); + let __v_580: G = (__v_577 + __v_579); + let __v_581: G = (__v_575 + __v_580); + let __v_582: G = (__v_250 + __v_581); + let __v_583: G = G::from_u64(256); + let __v_584: G = (__v_583 * __v_255); + let __v_585: G = G::from_u64(65536); + let __v_586: G = (__v_585 * __v_256); + let __v_587: G = G::from_u64(16777216); + let __v_588: G = (__v_587 * __v_257); + let __v_589: G = (__v_586 + __v_588); + let __v_590: G = (__v_584 + __v_589); + let __v_591: G = (__v_254 + __v_590); + let __v_592: G = G::from_u64(256); + let __v_593: G = (__v_592 * __v_259); + let __v_594: G = G::from_u64(65536); + let __v_595: G = (__v_594 * __v_260); + let __v_596: G = G::from_u64(16777216); + let __v_597: G = (__v_596 * __v_261); + let __v_598: G = (__v_595 + __v_597); + let __v_599: G = (__v_593 + __v_598); + let __v_600: G = (__v_258 + __v_599); + let __v_601: G = G::from_u64(256); + let __v_602: G = (__v_601 * __v_263); + let __v_603: G = G::from_u64(65536); + let __v_604: G = (__v_603 * __v_264); + let __v_605: G = G::from_u64(16777216); + let __v_606: G = (__v_605 * __v_265); + let __v_607: G = (__v_604 + __v_606); + let __v_608: G = (__v_602 + __v_607); + let __v_609: G = (__v_262 + __v_608); + let __v_610: G = G::from_u64(256); + let __v_611: G = (__v_610 * __v_267); + let __v_612: G = G::from_u64(65536); + let __v_613: G = (__v_612 * __v_268); + let __v_614: G = G::from_u64(16777216); + let __v_615: G = (__v_614 * __v_269); + let __v_616: G = (__v_613 + __v_615); + let __v_617: G = (__v_611 + __v_616); + let __v_618: G = (__v_266 + __v_617); + let __v_619: G = G::from_u64(256); + let __v_620: G = (__v_619 * __v_271); + let __v_621: G = G::from_u64(65536); + let __v_622: G = (__v_621 * __v_272); + let __v_623: G = G::from_u64(16777216); + let __v_624: G = (__v_623 * __v_273); + let __v_625: G = (__v_622 + __v_624); + let __v_626: G = (__v_620 + __v_625); + let __v_627: G = (__v_270 + __v_626); + let __v_628: G = G::from_u64(256); + let __v_629: G = (__v_628 * __v_275); + let __v_630: G = G::from_u64(65536); + let __v_631: G = (__v_630 * __v_276); + let __v_632: G = G::from_u64(16777216); + let __v_633: G = (__v_632 * __v_277); + let __v_634: G = (__v_631 + __v_633); + let __v_635: G = (__v_629 + __v_634); + let __v_636: G = (__v_274 + __v_635); + let __v_637: G = G::from_u64(256); + let __v_638: G = (__v_637 * __v_279); + let __v_639: G = G::from_u64(65536); + let __v_640: G = (__v_639 * __v_280); + let __v_641: G = G::from_u64(16777216); + let __v_642: G = (__v_641 * __v_281); + let __v_643: G = (__v_640 + __v_642); + let __v_644: G = (__v_638 + __v_643); + let __v_645: G = (__v_278 + __v_644); + if (__v_582 != __v_181) { + return Err(ExecError::AssertEqMismatch { lhs: __v_582.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_591 != __v_182) { + return Err(ExecError::AssertEqMismatch { lhs: __v_591.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_600 != __v_183) { + return Err(ExecError::AssertEqMismatch { lhs: __v_600.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_609 != __v_184) { + return Err(ExecError::AssertEqMismatch { lhs: __v_609.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_618 != __v_185) { + return Err(ExecError::AssertEqMismatch { lhs: __v_618.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_627 != __v_186) { + return Err(ExecError::AssertEqMismatch { lhs: __v_627.as_canonical_u64(), rhs: __v_186.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_636 != __v_187) { + return Err(ExecError::AssertEqMismatch { lhs: __v_636.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_645 != __v_188) { + return Err(ExecError::AssertEqMismatch { lhs: __v_645.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_2] = { let __args: [G; IN_2] = [__v_537, __v_540]; 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_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 __v_646: G = __loaded[0]; + let __v_647: G = __loaded[1]; + let __v_648: G = __loaded[2]; + let __v_649: G = G::from_u64(1); + let __v_650: G = G::from_u64(1); + if (__v_646 != __v_649) { + return Err(ExecError::AssertEqMismatch { lhs: __v_646.as_canonical_u64(), rhs: __v_649.as_canonical_u64(), msg: None }); + } + if (__v_647 != __v_650) { + return Err(ExecError::AssertEqMismatch { lhs: __v_647.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: None }); + } + if (__v_648 != __v_650) { + return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: None }); + } + let __v_651: G = G::from_u64(256); + let __v_652: G = (__v_651 * __v_458); + let __v_653: G = G::from_u64(65536); + let __v_654: G = (__v_653 * __v_459); + let __v_655: G = G::from_u64(16777216); + let __v_656: G = (__v_655 * __v_460); + let __v_657: G = (__v_654 + __v_656); + let __v_658: G = (__v_652 + __v_657); + let __v_659: G = (__v_457 + __v_658); + let __v_660: G = G::from_u64(256); + let __v_661: G = (__v_660 * __v_462); + let __v_662: G = G::from_u64(65536); + let __v_663: G = (__v_662 * __v_463); + let __v_664: G = G::from_u64(16777216); + let __v_665: G = (__v_664 * __v_464); + let __v_666: G = (__v_663 + __v_665); + let __v_667: G = (__v_661 + __v_666); + let __v_668: G = (__v_461 + __v_667); + let __v_669: G = G::from_u64(256); + let __v_670: G = (__v_669 * __v_466); + let __v_671: G = G::from_u64(65536); + let __v_672: G = (__v_671 * __v_467); + let __v_673: G = G::from_u64(16777216); + let __v_674: G = (__v_673 * __v_468); + let __v_675: G = (__v_672 + __v_674); + let __v_676: G = (__v_670 + __v_675); + let __v_677: G = (__v_465 + __v_676); + let __v_678: G = G::from_u64(256); + let __v_679: G = (__v_678 * __v_470); + let __v_680: G = G::from_u64(65536); + let __v_681: G = (__v_680 * __v_471); + let __v_682: G = G::from_u64(16777216); + let __v_683: G = (__v_682 * __v_472); + let __v_684: G = (__v_681 + __v_683); + let __v_685: G = (__v_679 + __v_684); + let __v_686: G = (__v_469 + __v_685); + let __v_687: G = G::from_u64(256); + let __v_688: G = (__v_687 * __v_474); + let __v_689: G = G::from_u64(65536); + let __v_690: G = (__v_689 * __v_475); + let __v_691: G = G::from_u64(16777216); + let __v_692: G = (__v_691 * __v_476); + let __v_693: G = (__v_690 + __v_692); + let __v_694: G = (__v_688 + __v_693); + let __v_695: G = (__v_473 + __v_694); + let __v_696: G = G::from_u64(256); + let __v_697: G = (__v_696 * __v_478); + let __v_698: G = G::from_u64(65536); + let __v_699: G = (__v_698 * __v_479); + let __v_700: G = G::from_u64(16777216); + let __v_701: G = (__v_700 * __v_480); + let __v_702: G = (__v_699 + __v_701); + let __v_703: G = (__v_697 + __v_702); + let __v_704: G = (__v_477 + __v_703); + let __v_705: G = G::from_u64(256); + let __v_706: G = (__v_705 * __v_482); + let __v_707: G = G::from_u64(65536); + let __v_708: G = (__v_707 * __v_483); + let __v_709: G = G::from_u64(16777216); + let __v_710: G = (__v_709 * __v_484); + let __v_711: G = (__v_708 + __v_710); + let __v_712: G = (__v_706 + __v_711); + let __v_713: G = (__v_481 + __v_712); + let __v_714: G = G::from_u64(256); + let __v_715: G = (__v_714 * __v_486); + let __v_716: G = G::from_u64(65536); + let __v_717: G = (__v_716 * __v_487); + let __v_718: G = G::from_u64(16777216); + let __v_719: G = (__v_718 * __v_488); + let __v_720: G = (__v_717 + __v_719); + let __v_721: G = (__v_715 + __v_720); + let __v_722: G = (__v_485 + __v_721); + if (__v_659 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_659.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_668 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_668.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_677 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_677.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_686 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_686.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_695 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_695.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_704 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_704.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_713 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_713.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_722 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_722.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_489, __v_492]; 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_723: G = __r_arr[0]; + let __v_724: G = G::from_u64(1); + if (__v_723 != __v_724) { + return Err(ExecError::AssertEqMismatch { lhs: __v_723.as_canonical_u64(), rhs: __v_724.as_canonical_u64(), msg: Some("structural join: output subject root is not nodeHash(left, right)".to_string()) }); } let __ret: [G; OUT_240] = []; 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)); }; @@ -25600,204 +25403,145 @@ fn aiur_fn_241( let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_261, __v_246]; 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_262: G = __r_arr[0]; let __v_263: G = __r_arr[1]; - let __v_264: G = G::from_u64(1); - let __gb: [u8; 8] = __v_264.as_canonical_u64().to_le_bytes(); - let __v_265: G = G::from_u8(__gb[0]); - let __v_266: G = G::from_u8(__gb[1]); - let __v_267: G = G::from_u8(__gb[2]); - let __v_268: G = G::from_u8(__gb[3]); - let __v_269: G = G::from_u8(__gb[4]); - let __v_270: G = G::from_u8(__gb[5]); - let __v_271: G = G::from_u8(__gb[6]); - let __v_272: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_265; let __vj = __v_266; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_267; let __vj = __v_268; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_269; let __vj = __v_270; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_271; let __vj = __v_272; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - let __v_273: G = G::from_u64(1020); - let __v_274: G = (__v_272 - __v_273); - let __v_275: G = (__v_271 + __v_274); - let __v_276: G = (__v_270 + __v_275); - let __v_277: G = (__v_269 + __v_276); - let __v_278: G = G::from_bool((__v_277 == G::ZERO)); - let __v_279: G = (__v_267 + __v_268); - let __v_280: G = (__v_266 + __v_279); - let __v_281: G = (__v_265 + __v_280); - let __v_282: G = G::from_bool((__v_281 == G::ZERO)); - let __v_283: G = G::from_u64(256); - let __v_284: G = (__v_283 * __v_266); - let __v_285: G = G::from_u64(65536); - let __v_286: G = (__v_285 * __v_267); - let __v_287: G = G::from_u64(16777216); - let __v_288: G = (__v_287 * __v_268); - let __v_289: G = G::from_u64(4294967296); - let __v_290: G = (__v_289 * __v_269); - let __v_291: G = G::from_u64(1099511627776); - let __v_292: G = (__v_291 * __v_270); - let __v_293: G = G::from_u64(281474976710656); - let __v_294: G = (__v_293 * __v_271); - let __v_295: G = G::from_u64(72057594037927936); - let __v_296: G = (__v_295 * __v_272); - let __v_297: G = (__v_294 + __v_296); - let __v_298: G = (__v_292 + __v_297); - let __v_299: G = (__v_290 + __v_298); - let __v_300: G = (__v_288 + __v_299); - let __v_301: G = (__v_286 + __v_300); - let __v_302: G = (__v_284 + __v_301); - let __v_303: G = (__v_265 + __v_302); - if (__v_303 != __v_264) { - return Err(ExecError::AssertEqMismatch { lhs: __v_303.as_canonical_u64(), rhs: __v_264.as_canonical_u64(), msg: None }); - } - let __v_304: G = G::from_u64(1); + let __v_264: G = G::from_u64(0); + let __v_265: G = { let __values: [G; 10] = [__v_264, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_257]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_245, __v_265]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __v_266: G = __r_arr[0]; + let __v_267: G = G::from_u64(2); + let __v_268: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_268]; let __info = io_buffer.get_info(__v_267, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_269: G = __io_pair.0; + let __v_270: G = __io_pair.1; + let __v_271: G = G::from_u64(2); + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_271, __v_269, __v_270]; let __cu = true; 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 { 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_272: G = __r_arr[0]; + let __v_273: G = G::from_u64(103); + let __v_274: G = G::from_u64(230); + let __v_275: G = G::from_u64(9); + let __v_276: G = G::from_u64(106); + let __v_277: G = G::from_u64(133); + let __v_278: G = G::from_u64(174); + let __v_279: G = G::from_u64(103); + let __v_280: G = G::from_u64(187); + let __v_281: G = G::from_u64(114); + let __v_282: G = G::from_u64(243); + let __v_283: G = G::from_u64(110); + let __v_284: G = G::from_u64(60); + let __v_285: G = G::from_u64(58); + let __v_286: G = G::from_u64(245); + let __v_287: G = G::from_u64(79); + let __v_288: G = G::from_u64(165); + let __v_289: G = G::from_u64(127); + let __v_290: G = G::from_u64(82); + let __v_291: G = G::from_u64(14); + let __v_292: G = G::from_u64(81); + let __v_293: G = G::from_u64(140); + let __v_294: G = G::from_u64(104); + let __v_295: G = G::from_u64(5); + let __v_296: G = G::from_u64(155); + let __v_297: G = G::from_u64(171); + let __v_298: G = G::from_u64(217); + let __v_299: G = G::from_u64(131); + let __v_300: G = G::from_u64(31); + let __v_301: G = G::from_u64(25); + let __v_302: G = G::from_u64(205); + let __v_303: G = G::from_u64(224); + let __v_304: G = G::from_u64(91); let __v_305: G = G::from_u64(1); - let __v_306: G = (__v_305 - __v_282); - let __v_307: G = (__v_278 * __v_306); - let __v_308: G = (__v_304 - __v_307); - let __v_309: G = G::from_u64(1); - if (__v_308 != __v_309) { - return Err(ExecError::AssertEqMismatch { lhs: __v_308.as_canonical_u64(), rhs: __v_309.as_canonical_u64(), msg: None }); - } + let __v_306: G = G::from_u64(1); + let __v_307: G = { let __values: [G; 3] = [__v_305, __v_306, __v_306]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + 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_312: G = { let __values: [G; 10] = [__v_311, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_257]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_313: G = { let __values: [G; 10] = [__v_310, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_312]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_245, __v_313]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; - let __v_314: G = __r_arr[0]; - let __v_315: 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 = G::from_u64(0); + let __v_315: G = G::from_u64(0); let __v_316: G = G::from_u64(0); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_316]; let __info = io_buffer.get_info(__v_315, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_317: G = __io_pair.0; - let __v_318: G = __io_pair.1; - let __v_319: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_319, __v_317, __v_318]; let __cu = true; 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 { 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_320: G = __r_arr[0]; - let __v_321: G = G::from_u64(103); - let __v_322: G = G::from_u64(230); - let __v_323: G = G::from_u64(9); - let __v_324: G = G::from_u64(106); - let __v_325: G = G::from_u64(133); - let __v_326: G = G::from_u64(174); - let __v_327: G = G::from_u64(103); - let __v_328: G = G::from_u64(187); - let __v_329: G = G::from_u64(114); - let __v_330: G = G::from_u64(243); - let __v_331: G = G::from_u64(110); - let __v_332: G = G::from_u64(60); - let __v_333: G = G::from_u64(58); - let __v_334: G = G::from_u64(245); - let __v_335: G = G::from_u64(79); - let __v_336: G = G::from_u64(165); - let __v_337: G = G::from_u64(127); - let __v_338: G = G::from_u64(82); - let __v_339: G = G::from_u64(14); - let __v_340: G = G::from_u64(81); - let __v_341: G = G::from_u64(140); - let __v_342: G = G::from_u64(104); - let __v_343: G = G::from_u64(5); - let __v_344: G = G::from_u64(155); - let __v_345: G = G::from_u64(171); - let __v_346: G = G::from_u64(217); - let __v_347: G = G::from_u64(131); - let __v_348: G = G::from_u64(31); - let __v_349: G = G::from_u64(25); - let __v_350: G = G::from_u64(205); - let __v_351: G = G::from_u64(224); - let __v_352: G = G::from_u64(91); - let __v_353: G = G::from_u64(1); - let __v_354: G = G::from_u64(1); - let __v_355: G = { let __values: [G; 3] = [__v_353, __v_354, __v_354]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_356: G = G::from_u64(0); - let __v_357: G = G::from_u64(0); - let __v_358: G = G::from_u64(0); - let __v_359: G = G::from_u64(0); - let __v_360: G = G::from_u64(0); - let __v_361: G = G::from_u64(0); - let __v_362: G = G::from_u64(0); - let __v_363: G = G::from_u64(0); - let __v_364: G = G::from_u64(0); - let __v_365: G = G::from_u64(0); - let __v_366: G = { let __values: [G; 8] = [__v_358, __v_359, __v_360, __v_361, __v_362, __v_363, __v_364, __v_365]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 32] = [__v_321, __v_322, __v_323, __v_324, __v_325, __v_326, __v_327, __v_328, __v_329, __v_330, __v_331, __v_332, __v_333, __v_334, __v_335, __v_336, __v_337, __v_338, __v_339, __v_340, __v_341, __v_342, __v_343, __v_344, __v_345, __v_346, __v_347, __v_348, __v_349, __v_350, __v_351, __v_352]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1); - let __v_369: G = G::from_u64(1); - let __v_370: G = { let __values: [G; 34] = [__v_368, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_320, __v_355, __v_356, __v_357, __v_366, __v_367, __v_370]; 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_371: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_371]; 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_372: G = __r_arr[0]; - let __v_373: G = __r_arr[1]; - let __v_374: G = __r_arr[2]; - let __v_375: G = __r_arr[3]; - let __v_376: G = __r_arr[4]; - let __v_377: G = __r_arr[5]; - let __v_378: G = __r_arr[6]; - let __v_379: G = __r_arr[7]; - let __v_380: G = __r_arr[8]; - let __v_381: G = __r_arr[9]; - let __v_382: G = __r_arr[10]; - let __v_383: G = __r_arr[11]; - let __v_384: G = __r_arr[12]; - let __v_385: G = __r_arr[13]; - let __v_386: G = __r_arr[14]; - let __v_387: G = __r_arr[15]; - let __v_388: G = __r_arr[16]; - let __v_389: G = __r_arr[17]; - let __v_390: G = __r_arr[18]; - let __v_391: G = __r_arr[19]; - let __v_392: G = __r_arr[20]; - let __v_393: G = __r_arr[21]; - let __v_394: G = __r_arr[22]; - let __v_395: G = __r_arr[23]; - let __v_396: G = __r_arr[24]; - let __v_397: G = __r_arr[25]; - let __v_398: G = __r_arr[26]; - let __v_399: G = __r_arr[27]; - let __v_400: G = __r_arr[28]; - let __v_401: G = __r_arr[29]; - let __v_402: G = __r_arr[30]; - let __v_403: G = __r_arr[31]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_320]; let __cu = unconstrained; 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_404: G = __r_arr[0]; - let __v_405: G = __r_arr[1]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_405, __v_404]; let __cu = unconstrained; 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_406: G = __r_arr[0]; - let __v_407: G = __r_arr[1]; + let __v_317: G = G::from_u64(0); + let __v_318: G = { let __values: [G; 8] = [__v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317]; 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_319: G = { let __values: [G; 32] = [__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, __v_301, __v_302, __v_303, __v_304]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_320: G = G::from_u64(1); + let __v_321: G = G::from_u64(1); + let __v_322: G = { let __values: [G; 34] = [__v_320, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321]; 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_272, __v_307, __v_308, __v_309, __v_318, __v_319, __v_322]; 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_323: G = __r_arr[0]; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_323]; 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_324: G = __r_arr[0]; + let __v_325: G = __r_arr[1]; + let __v_326: G = __r_arr[2]; + let __v_327: G = __r_arr[3]; + let __v_328: G = __r_arr[4]; + let __v_329: G = __r_arr[5]; + let __v_330: G = __r_arr[6]; + let __v_331: G = __r_arr[7]; + let __v_332: G = __r_arr[8]; + let __v_333: G = __r_arr[9]; + let __v_334: G = __r_arr[10]; + let __v_335: G = __r_arr[11]; + let __v_336: G = __r_arr[12]; + let __v_337: G = __r_arr[13]; + let __v_338: G = __r_arr[14]; + let __v_339: G = __r_arr[15]; + let __v_340: G = __r_arr[16]; + let __v_341: G = __r_arr[17]; + let __v_342: G = __r_arr[18]; + let __v_343: G = __r_arr[19]; + let __v_344: G = __r_arr[20]; + let __v_345: G = __r_arr[21]; + let __v_346: G = __r_arr[22]; + let __v_347: G = __r_arr[23]; + let __v_348: G = __r_arr[24]; + let __v_349: G = __r_arr[25]; + let __v_350: G = __r_arr[26]; + let __v_351: G = __r_arr[27]; + let __v_352: G = __r_arr[28]; + let __v_353: G = __r_arr[29]; + let __v_354: G = __r_arr[30]; + let __v_355: G = __r_arr[31]; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_272]; 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_356: G = __r_arr[0]; + let __v_357: G = __r_arr[1]; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_357, __v_356]; 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_358: G = __r_arr[0]; + let __v_359: G = __r_arr[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_22.as_canonical_u64() { _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_30]; 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_408: G = __r_arr[0]; - let __v_409: G = G::from_bool((__v_408 == G::ZERO)); - let __v_410: G = G::from_u64(0); - if (__v_409 != __v_410) { - return Err(ExecError::AssertEqMismatch { lhs: __v_409.as_canonical_u64(), rhs: __v_410.as_canonical_u64(), msg: None }); + let __v_360: G = __r_arr[0]; + let __v_361: G = G::from_bool((__v_360 == G::ZERO)); + let __v_362: G = G::from_u64(0); + if (__v_361 != __v_362) { + return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_362.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_66]; 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_411: G = __r_arr[0]; - if (__v_411 != __v_408) { - return Err(ExecError::AssertEqMismatch { lhs: __v_411.as_canonical_u64(), rhs: __v_408.as_canonical_u64(), msg: None }); + let __v_363: G = __r_arr[0]; + if (__v_363 != __v_360) { + return Err(ExecError::AssertEqMismatch { lhs: __v_363.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_68]; 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_412: G = __r_arr[0]; - if (__v_412 != __v_408) { - return Err(ExecError::AssertEqMismatch { lhs: __v_412.as_canonical_u64(), rhs: __v_408.as_canonical_u64(), msg: None }); + let __v_364: G = __r_arr[0]; + if (__v_364 != __v_360) { + return Err(ExecError::AssertEqMismatch { lhs: __v_364.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_61]; 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_413: G = __r_arr[0]; - if (__v_413 != __v_408) { - return Err(ExecError::AssertEqMismatch { lhs: __v_413.as_canonical_u64(), rhs: __v_408.as_canonical_u64(), msg: None }); + let __v_365: G = __r_arr[0]; + if (__v_365 != __v_360) { + return Err(ExecError::AssertEqMismatch { lhs: __v_365.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; - let __v_414: G = __r_arr[0]; - let __v_415: G = G::from_u64(1); - if (__v_414 != __v_415) { - return Err(ExecError::AssertEqMismatch { lhs: __v_414.as_canonical_u64(), rhs: __v_415.as_canonical_u64(), msg: None }); + let __v_366: G = __r_arr[0]; + let __v_367: G = G::from_u64(1); + if (__v_366 != __v_367) { + return Err(ExecError::AssertEqMismatch { lhs: __v_366.as_canonical_u64(), rhs: __v_367.as_canonical_u64(), msg: None }); } - let __v_416: G = G::from_u64(1); - break '__mc_0 [__v_416]; + let __v_368: G = G::from_u64(1); + break '__mc_0 [__v_368]; }, } }; - let __v_408: G = __mc_out___mc_0[0]; + let __v_360: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_159.as_canonical_u64() { _ => { match __v_159.as_canonical_u64() { @@ -25805,17 +25549,17 @@ fn aiur_fn_241( match __v_22.as_canonical_u64() { _ => { let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_256, __v_22]; 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_409: G = __r_arr[0]; + let __v_361: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_262, __v_22]; 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_410: G = __r_arr[0]; + let __v_362: G = __r_arr[0]; match __v_24.as_canonical_u64() { _ => { let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_259.as_canonical_u64() { 0u64 => { - let __v_411: G = G::from_u64(1); - let __v_412: G = G::from_u64(1); - let __v_413: G = { let __values: [G; 3] = [__v_411, __v_412, __v_412]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *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_413]; + let __v_363: G = G::from_u64(1); + let __v_364: G = G::from_u64(1); + let __v_365: G = { let __values: [G; 3] = [__v_363, __v_364, __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 } }; + break '__mc_2 [__v_365]; }, 1u64 => { break '__mc_2 [__v_260]; @@ -25825,556 +25569,556 @@ fn aiur_fn_241( }, } }; - let __v_411: G = __mc_out___mc_2[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_34, __v_320]; let __cu = unconstrained; 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_412: G = __r_arr[0]; - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_24, __v_412]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; - let __v_413: G = __r_arr[0]; - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_411, __v_413]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __v_363: G = __mc_out___mc_2[0]; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_34, __v_272]; 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_364: G = __r_arr[0]; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_24, __v_364]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __v_365: G = __r_arr[0]; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_363, __v_365]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __v_366: G = __r_arr[0]; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_22, __v_366]; 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_367: G = __r_arr[0]; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_266, __v_367]; 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_368: G = __r_arr[0]; + let __v_369: G = G::from_u64(0); + let __v_370: G = G::from_u64(109); + let __v_371: G = G::from_u64(0); + let __v_372: G = G::from_u64(117); + let __v_373: G = G::from_u64(0); + let __v_374: G = G::from_u64(108); + let __v_375: G = G::from_u64(0); + let __v_376: G = G::from_u64(116); + let __v_377: G = G::from_u64(0); + let __v_378: G = G::from_u64(105); + let __v_379: G = G::from_u64(0); + let __v_380: G = G::from_u64(45); + let __v_381: G = G::from_u64(0); + let __v_382: G = G::from_u64(115); + let __v_383: G = G::from_u64(0); + let __v_384: G = G::from_u64(116); + let __v_385: G = G::from_u64(0); + let __v_386: G = G::from_u64(97); + let __v_387: G = G::from_u64(0); + let __v_388: G = G::from_u64(114); + let __v_389: G = G::from_u64(0); + let __v_390: G = G::from_u64(107); + let __v_391: G = G::from_u64(0); + let __v_392: G = G::from_u64(47); + let __v_393: G = G::from_u64(0); + let __v_394: G = G::from_u64(118); + let __v_395: G = G::from_u64(0); + let __v_396: G = G::from_u64(48); + let __v_397: G = { let __values: [G; 3] = [__v_395, __v_396, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_393, __v_394, __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_391, __v_392, __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_389, __v_390, __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_387, __v_388, __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_385, __v_386, __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_383, __v_384, __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_381, __v_382, __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_379, __v_380, __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_377, __v_378, __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 = { let __values: [G; 3] = [__v_375, __v_376, __v_406]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_408: G = { let __values: [G; 3] = [__v_373, __v_374, __v_407]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_409: G = { let __values: [G; 3] = [__v_371, __v_372, __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 __v_410: G = { let __values: [G; 3] = [__v_369, __v_370, __v_409]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_411: G = G::from_u64(1); + let __v_412: G = G::from_u64(1); + let __v_413: G = { let __values: [G; 3] = [__v_411, __v_412, __v_412]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_410, __v_413]; 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_414: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_22, __v_414]; 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_415: G = __r_arr[0]; - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_314, __v_415]; 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_416: G = __r_arr[0]; - let __v_417: G = G::from_u64(0); - let __v_418: G = G::from_u64(109); - let __v_419: G = G::from_u64(0); - let __v_420: G = G::from_u64(117); - let __v_421: G = G::from_u64(0); - let __v_422: G = G::from_u64(108); - let __v_423: G = G::from_u64(0); - let __v_424: G = G::from_u64(116); - let __v_425: G = G::from_u64(0); - let __v_426: G = G::from_u64(105); - let __v_427: G = G::from_u64(0); - let __v_428: G = G::from_u64(45); - let __v_429: G = G::from_u64(0); - let __v_430: G = G::from_u64(115); - let __v_431: G = G::from_u64(0); - let __v_432: G = G::from_u64(116); - let __v_433: G = G::from_u64(0); - let __v_434: G = G::from_u64(97); - let __v_435: G = G::from_u64(0); - let __v_436: G = G::from_u64(114); - let __v_437: G = G::from_u64(0); - let __v_438: G = G::from_u64(107); - let __v_439: G = G::from_u64(0); - let __v_440: G = G::from_u64(47); - let __v_441: G = G::from_u64(0); - let __v_442: G = G::from_u64(118); - let __v_443: G = G::from_u64(0); - let __v_444: G = G::from_u64(48); - let __v_445: G = { let __values: [G; 3] = [__v_443, __v_444, __v_416]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_441, __v_442, __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_439, __v_440, __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_437, __v_438, __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_435, __v_436, __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_433, __v_434, __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_431, __v_432, __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_429, __v_430, __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_427, __v_428, __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_425, __v_426, __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 = { let __values: [G; 3] = [__v_423, __v_424, __v_454]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_456: G = { let __values: [G; 3] = [__v_421, __v_422, __v_455]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_457: G = { let __values: [G; 3] = [__v_419, __v_420, __v_456]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_458: G = { let __values: [G; 3] = [__v_417, __v_418, __v_457]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_415: G = __r_arr[1]; + let __v_416: G = __r_arr[2]; + let __v_417: G = __r_arr[3]; + let __v_418: G = __r_arr[4]; + let __v_419: G = __r_arr[5]; + let __v_420: G = __r_arr[6]; + let __v_421: G = __r_arr[7]; + let __v_422: G = __r_arr[8]; + let __v_423: G = __r_arr[9]; + let __v_424: G = __r_arr[10]; + let __v_425: G = __r_arr[11]; + let __v_426: G = __r_arr[12]; + let __v_427: G = __r_arr[13]; + let __v_428: G = __r_arr[14]; + let __v_429: G = __r_arr[15]; + let __v_430: G = __r_arr[16]; + let __v_431: G = __r_arr[17]; + let __v_432: G = G::from_u64(1); + let __v_433: G = G::from_u64(1); + let __v_434: G = { let __values: [G; 3] = [__v_432, __v_433, __v_433]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_434]; 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_435: G = __r_arr[0]; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_435]; 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_436: G = __r_arr[0]; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_430, __v_436]; 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_437: G = __r_arr[0]; + let __v_438: G = G::from_u64(1); + let __v_439: G = G::from_u64(1); + let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_437, __v_440]; 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_441: G = __r_arr[0]; + let __v_442: G = __r_arr[1]; + let __v_443: G = __r_arr[2]; + let __v_444: G = __r_arr[3]; + let __v_445: G = __r_arr[4]; + let __v_446: G = __r_arr[5]; + let __v_447: G = __r_arr[6]; + let __v_448: G = __r_arr[7]; + let __v_449: G = __r_arr[8]; + let __v_450: G = __r_arr[9]; + let __v_451: G = __r_arr[10]; + let __v_452: G = __r_arr[11]; + let __v_453: G = __r_arr[12]; + let __v_454: G = __r_arr[13]; + let __v_455: G = __r_arr[14]; + let __v_456: G = __r_arr[15]; + let __v_457: G = __r_arr[16]; + let __v_458: G = __r_arr[17]; let __v_459: G = G::from_u64(1); let __v_460: G = G::from_u64(1); let __v_461: G = { let __values: [G; 3] = [__v_459, __v_460, __v_460]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_458, __v_461]; 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_161] = { let __args: [G; IN_161] = [__v_449, __v_450, __v_451, __v_452, __v_453, __v_454, __v_455, __v_456, __v_461]; 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_462: G = __r_arr[0]; - let __v_463: G = __r_arr[1]; - let __v_464: G = __r_arr[2]; - let __v_465: G = __r_arr[3]; - let __v_466: G = __r_arr[4]; - let __v_467: G = __r_arr[5]; - let __v_468: G = __r_arr[6]; - let __v_469: G = __r_arr[7]; - let __v_470: G = __r_arr[8]; - let __v_471: G = __r_arr[9]; - let __v_472: G = __r_arr[10]; - let __v_473: G = __r_arr[11]; - let __v_474: G = __r_arr[12]; - let __v_475: G = __r_arr[13]; - let __v_476: G = __r_arr[14]; - let __v_477: G = __r_arr[15]; - let __v_478: G = __r_arr[16]; - let __v_479: G = __r_arr[17]; - let __v_480: G = G::from_u64(1); - let __v_481: G = G::from_u64(1); - let __v_482: G = { let __values: [G; 3] = [__v_480, __v_481, __v_481]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_470, __v_471, __v_472, __v_473, __v_474, __v_475, __v_476, __v_477, __v_482]; let __cu = unconstrained; 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_483: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_462, __v_463, __v_464, __v_465, __v_466, __v_467, __v_468, __v_469, __v_483]; let __cu = unconstrained; 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_484: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_478, __v_484]; 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_485: G = __r_arr[0]; - let __v_486: G = G::from_u64(1); - let __v_487: G = G::from_u64(1); - let __v_488: G = { let __values: [G; 3] = [__v_486, __v_487, __v_487]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_485, __v_488]; 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_489: G = __r_arr[0]; - let __v_490: G = __r_arr[1]; - let __v_491: G = __r_arr[2]; - let __v_492: G = __r_arr[3]; - let __v_493: G = __r_arr[4]; - let __v_494: G = __r_arr[5]; - let __v_495: G = __r_arr[6]; - let __v_496: G = __r_arr[7]; - let __v_497: G = __r_arr[8]; - let __v_498: G = __r_arr[9]; - let __v_499: G = __r_arr[10]; - let __v_500: G = __r_arr[11]; - let __v_501: G = __r_arr[12]; - let __v_502: G = __r_arr[13]; - let __v_503: G = __r_arr[14]; - let __v_504: G = __r_arr[15]; - let __v_505: G = __r_arr[16]; - let __v_506: G = __r_arr[17]; - let __v_507: G = G::from_u64(1); - let __v_508: G = G::from_u64(1); - let __v_509: G = { let __values: [G; 3] = [__v_507, __v_508, __v_508]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_497, __v_498, __v_499, __v_500, __v_501, __v_502, __v_503, __v_504, __v_509]; let __cu = unconstrained; 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_510: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_489, __v_490, __v_491, __v_492, __v_493, __v_494, __v_495, __v_496, __v_510]; let __cu = unconstrained; 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_511: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_505, __v_511]; 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_512: G = __r_arr[0]; - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_512, __v_26]; 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_513: G = __r_arr[0]; - let __v_514: G = G::from_u64(1); - let __v_515: G = G::from_u64(1); - let __v_516: G = { let __values: [G; 3] = [__v_514, __v_515, __v_515]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_30, __v_516]; 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_517: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_513, __v_517]; 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_518: G = __r_arr[0]; - let __v_519: G = G::from_u64(1); - let __v_520: G = G::from_u64(1); - let __v_521: G = { let __values: [G; 3] = [__v_519, __v_520, __v_520]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_518, __v_521]; 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_522: G = __r_arr[0]; - let __v_523: G = __r_arr[1]; - let __v_524: G = __r_arr[2]; - let __v_525: G = __r_arr[3]; - let __v_526: G = __r_arr[4]; - let __v_527: G = __r_arr[5]; - let __v_528: G = __r_arr[6]; - let __v_529: G = __r_arr[7]; - let __v_530: G = __r_arr[8]; - let __v_531: G = __r_arr[9]; - let __v_532: G = __r_arr[10]; - let __v_533: G = __r_arr[11]; - let __v_534: G = __r_arr[12]; - let __v_535: G = __r_arr[13]; - let __v_536: G = __r_arr[14]; - let __v_537: G = __r_arr[15]; - let __v_538: G = __r_arr[16]; - let __v_539: G = __r_arr[17]; - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_538, __v_28]; let __cu = unconstrained; 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_540: G = __r_arr[0]; - let __v_541: G = G::from_u64(1); - let __v_542: G = G::from_u64(1); - let __v_543: G = { let __values: [G; 3] = [__v_541, __v_542, __v_542]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_540, __v_543]; 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_544: G = __r_arr[0]; - let __v_545: G = __r_arr[1]; - let __v_546: G = __r_arr[2]; - let __v_547: G = __r_arr[3]; - let __v_548: G = __r_arr[4]; - let __v_549: G = __r_arr[5]; - let __v_550: G = __r_arr[6]; - let __v_551: G = __r_arr[7]; - let __v_552: G = __r_arr[8]; - let __v_553: G = __r_arr[9]; - let __v_554: G = __r_arr[10]; - let __v_555: G = __r_arr[11]; - let __v_556: G = __r_arr[12]; - let __v_557: G = __r_arr[13]; - let __v_558: G = __r_arr[14]; - let __v_559: G = __r_arr[15]; - let __v_560: G = __r_arr[16]; - let __v_561: G = __r_arr[17]; - let __v_562: G = G::from_u64(256); - let __v_563: G = (__v_562 * __v_463); - let __v_564: G = G::from_u64(65536); - let __v_565: G = (__v_564 * __v_464); - let __v_566: G = G::from_u64(16777216); - let __v_567: G = (__v_566 * __v_465); - let __v_568: G = G::from_u64(4294967296); - let __v_569: G = (__v_568 * __v_466); - let __v_570: G = G::from_u64(1099511627776); - let __v_571: G = (__v_570 * __v_467); - let __v_572: G = G::from_u64(281474976710656); - let __v_573: G = (__v_572 * __v_468); - let __v_574: G = G::from_u64(72057594037927936); - let __v_575: G = (__v_574 * __v_469); - let __v_576: G = (__v_573 + __v_575); - let __v_577: G = (__v_571 + __v_576); - let __v_578: G = (__v_569 + __v_577); - let __v_579: G = (__v_567 + __v_578); - let __v_580: G = (__v_565 + __v_579); - let __v_581: G = (__v_563 + __v_580); - let __v_582: G = (__v_462 + __v_581); - let __v_583: G = G::from_u64(256); - let __v_584: G = (__v_583 * __v_471); - let __v_585: G = G::from_u64(65536); - let __v_586: G = (__v_585 * __v_472); - let __v_587: G = G::from_u64(16777216); - let __v_588: G = (__v_587 * __v_473); - let __v_589: G = G::from_u64(4294967296); - let __v_590: G = (__v_589 * __v_474); - let __v_591: G = G::from_u64(1099511627776); - let __v_592: G = (__v_591 * __v_475); - let __v_593: G = G::from_u64(281474976710656); - let __v_594: G = (__v_593 * __v_476); - let __v_595: G = G::from_u64(72057594037927936); - let __v_596: G = (__v_595 * __v_477); - let __v_597: G = (__v_594 + __v_596); - let __v_598: G = (__v_592 + __v_597); - let __v_599: G = (__v_590 + __v_598); - let __v_600: G = (__v_588 + __v_599); - let __v_601: G = (__v_586 + __v_600); - let __v_602: G = (__v_584 + __v_601); - let __v_603: G = (__v_470 + __v_602); - let __v_604: G = G::from_u64(256); - let __v_605: G = (__v_604 * __v_490); - let __v_606: G = G::from_u64(65536); - let __v_607: G = (__v_606 * __v_491); - let __v_608: G = G::from_u64(16777216); - let __v_609: G = (__v_608 * __v_492); - let __v_610: G = G::from_u64(4294967296); - let __v_611: G = (__v_610 * __v_493); - let __v_612: G = G::from_u64(1099511627776); - let __v_613: G = (__v_612 * __v_494); - let __v_614: G = G::from_u64(281474976710656); - let __v_615: G = (__v_614 * __v_495); - let __v_616: G = G::from_u64(72057594037927936); - let __v_617: G = (__v_616 * __v_496); - let __v_618: G = (__v_615 + __v_617); - let __v_619: G = (__v_613 + __v_618); - let __v_620: G = (__v_611 + __v_619); - let __v_621: G = (__v_609 + __v_620); - let __v_622: G = (__v_607 + __v_621); - let __v_623: G = (__v_605 + __v_622); - let __v_624: G = (__v_489 + __v_623); - let __v_625: G = G::from_u64(256); - let __v_626: G = (__v_625 * __v_498); - let __v_627: G = G::from_u64(65536); - let __v_628: G = (__v_627 * __v_499); - let __v_629: G = G::from_u64(16777216); - let __v_630: G = (__v_629 * __v_500); - let __v_631: G = G::from_u64(4294967296); - let __v_632: G = (__v_631 * __v_501); - let __v_633: G = G::from_u64(1099511627776); - let __v_634: G = (__v_633 * __v_502); - let __v_635: G = G::from_u64(281474976710656); - let __v_636: G = (__v_635 * __v_503); - let __v_637: G = G::from_u64(72057594037927936); - let __v_638: G = (__v_637 * __v_504); - let __v_639: G = (__v_636 + __v_638); - let __v_640: G = (__v_634 + __v_639); - let __v_641: G = (__v_632 + __v_640); - let __v_642: G = (__v_630 + __v_641); - let __v_643: G = (__v_628 + __v_642); - let __v_644: G = (__v_626 + __v_643); - let __v_645: G = (__v_497 + __v_644); - let __v_646: G = G::from_u64(256); - let __v_647: G = (__v_646 * __v_523); - let __v_648: G = G::from_u64(65536); - let __v_649: G = (__v_648 * __v_524); - let __v_650: G = G::from_u64(16777216); - let __v_651: G = (__v_650 * __v_525); - let __v_652: G = G::from_u64(4294967296); - let __v_653: G = (__v_652 * __v_526); - let __v_654: G = G::from_u64(1099511627776); - let __v_655: G = (__v_654 * __v_527); - let __v_656: G = G::from_u64(281474976710656); - let __v_657: G = (__v_656 * __v_528); - let __v_658: G = G::from_u64(72057594037927936); - let __v_659: G = (__v_658 * __v_529); - let __v_660: G = (__v_657 + __v_659); - let __v_661: G = (__v_655 + __v_660); - let __v_662: G = (__v_653 + __v_661); - let __v_663: G = (__v_651 + __v_662); - let __v_664: G = (__v_649 + __v_663); - let __v_665: G = (__v_647 + __v_664); - let __v_666: G = (__v_522 + __v_665); - let __v_667: G = G::from_u64(256); - let __v_668: G = (__v_667 * __v_531); - let __v_669: G = G::from_u64(65536); - let __v_670: G = (__v_669 * __v_532); - let __v_671: G = G::from_u64(16777216); - let __v_672: G = (__v_671 * __v_533); - let __v_673: G = G::from_u64(4294967296); - let __v_674: G = (__v_673 * __v_534); - let __v_675: G = G::from_u64(1099511627776); - let __v_676: G = (__v_675 * __v_535); - let __v_677: G = G::from_u64(281474976710656); - let __v_678: G = (__v_677 * __v_536); - let __v_679: G = G::from_u64(72057594037927936); - let __v_680: G = (__v_679 * __v_537); - let __v_681: G = (__v_678 + __v_680); - let __v_682: G = (__v_676 + __v_681); - let __v_683: G = (__v_674 + __v_682); - let __v_684: G = (__v_672 + __v_683); - let __v_685: G = (__v_670 + __v_684); - let __v_686: G = (__v_668 + __v_685); - let __v_687: G = (__v_530 + __v_686); - let __v_688: G = G::from_u64(256); - let __v_689: G = (__v_688 * __v_545); - let __v_690: G = G::from_u64(65536); - let __v_691: G = (__v_690 * __v_546); - let __v_692: G = G::from_u64(16777216); - let __v_693: G = (__v_692 * __v_547); - let __v_694: G = G::from_u64(4294967296); - let __v_695: G = (__v_694 * __v_548); - let __v_696: G = G::from_u64(1099511627776); - let __v_697: G = (__v_696 * __v_549); - let __v_698: G = G::from_u64(281474976710656); - let __v_699: G = (__v_698 * __v_550); - let __v_700: G = G::from_u64(72057594037927936); - let __v_701: G = (__v_700 * __v_551); - let __v_702: G = (__v_699 + __v_701); - let __v_703: G = (__v_697 + __v_702); - let __v_704: G = (__v_695 + __v_703); - let __v_705: G = (__v_693 + __v_704); - let __v_706: G = (__v_691 + __v_705); - let __v_707: G = (__v_689 + __v_706); - let __v_708: G = (__v_544 + __v_707); - let __v_709: G = G::from_u64(256); - let __v_710: G = (__v_709 * __v_553); - let __v_711: G = G::from_u64(65536); - let __v_712: G = (__v_711 * __v_554); - let __v_713: G = G::from_u64(16777216); - let __v_714: G = (__v_713 * __v_555); - let __v_715: G = G::from_u64(4294967296); - let __v_716: G = (__v_715 * __v_556); - let __v_717: G = G::from_u64(1099511627776); - let __v_718: G = (__v_717 * __v_557); - let __v_719: G = G::from_u64(281474976710656); - let __v_720: G = (__v_719 * __v_558); - let __v_721: G = G::from_u64(72057594037927936); - let __v_722: G = (__v_721 * __v_559); - let __v_723: G = (__v_720 + __v_722); - let __v_724: G = (__v_718 + __v_723); - let __v_725: G = (__v_716 + __v_724); - let __v_726: G = (__v_714 + __v_725); - let __v_727: G = (__v_712 + __v_726); - let __v_728: G = (__v_710 + __v_727); - let __v_729: G = (__v_552 + __v_728); - let __v_730: G = G::from_u64(0); - let __v_731: G = G::from_u64(0); - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_730, __v_731, __v_406, __v_582, __v_603, __v_624, __v_645]; let __cu = unconstrained; 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_732: G = __r_arr[0]; - let __v_733: G = __r_arr[1]; - let __v_734: G = G::from_u64(0); - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_409, __v_410, __v_34, __v_30, __v_66, __v_68, __v_63, __v_64, __v_61, __v_734, __v_732, __v_733, __v_582, __v_603, __v_624, __v_645, __v_666, __v_687, __v_708, __v_729]; let __cu = unconstrained; 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_735: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_409]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; - let __v_736: G = __r_arr[0]; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_462]; 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_463: G = __r_arr[0]; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_457, __v_463]; 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_464: G = __r_arr[0]; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_464, __v_26]; 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_465: G = __r_arr[0]; + let __v_466: G = G::from_u64(1); + let __v_467: G = G::from_u64(1); + let __v_468: G = { let __values: [G; 3] = [__v_466, __v_467, __v_467]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_30, __v_468]; 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_469: G = __r_arr[0]; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_465, __v_469]; 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_470: G = __r_arr[0]; + let __v_471: G = G::from_u64(1); + let __v_472: G = G::from_u64(1); + let __v_473: G = { let __values: [G; 3] = [__v_471, __v_472, __v_472]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_470, __v_473]; 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_474: G = __r_arr[0]; + let __v_475: G = __r_arr[1]; + let __v_476: G = __r_arr[2]; + let __v_477: G = __r_arr[3]; + let __v_478: G = __r_arr[4]; + let __v_479: G = __r_arr[5]; + let __v_480: G = __r_arr[6]; + let __v_481: G = __r_arr[7]; + let __v_482: G = __r_arr[8]; + let __v_483: G = __r_arr[9]; + let __v_484: G = __r_arr[10]; + let __v_485: G = __r_arr[11]; + let __v_486: G = __r_arr[12]; + let __v_487: G = __r_arr[13]; + let __v_488: G = __r_arr[14]; + let __v_489: G = __r_arr[15]; + let __v_490: G = __r_arr[16]; + let __v_491: G = __r_arr[17]; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_490, __v_28]; 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_492: G = __r_arr[0]; + let __v_493: G = G::from_u64(1); + let __v_494: G = G::from_u64(1); + let __v_495: G = { let __values: [G; 3] = [__v_493, __v_494, __v_494]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_492, __v_495]; 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_496: G = __r_arr[0]; + let __v_497: G = __r_arr[1]; + let __v_498: G = __r_arr[2]; + let __v_499: G = __r_arr[3]; + let __v_500: G = __r_arr[4]; + let __v_501: G = __r_arr[5]; + let __v_502: G = __r_arr[6]; + let __v_503: G = __r_arr[7]; + let __v_504: G = __r_arr[8]; + let __v_505: G = __r_arr[9]; + let __v_506: G = __r_arr[10]; + let __v_507: G = __r_arr[11]; + let __v_508: G = __r_arr[12]; + let __v_509: G = __r_arr[13]; + let __v_510: G = __r_arr[14]; + let __v_511: G = __r_arr[15]; + let __v_512: G = __r_arr[16]; + let __v_513: G = __r_arr[17]; + let __v_514: G = G::from_u64(256); + let __v_515: G = (__v_514 * __v_415); + let __v_516: G = G::from_u64(65536); + let __v_517: G = (__v_516 * __v_416); + let __v_518: G = G::from_u64(16777216); + let __v_519: G = (__v_518 * __v_417); + let __v_520: G = G::from_u64(4294967296); + let __v_521: G = (__v_520 * __v_418); + let __v_522: G = G::from_u64(1099511627776); + let __v_523: G = (__v_522 * __v_419); + let __v_524: G = G::from_u64(281474976710656); + let __v_525: G = (__v_524 * __v_420); + let __v_526: G = G::from_u64(72057594037927936); + let __v_527: G = (__v_526 * __v_421); + let __v_528: G = (__v_525 + __v_527); + let __v_529: G = (__v_523 + __v_528); + let __v_530: G = (__v_521 + __v_529); + let __v_531: G = (__v_519 + __v_530); + let __v_532: G = (__v_517 + __v_531); + let __v_533: G = (__v_515 + __v_532); + let __v_534: G = (__v_414 + __v_533); + let __v_535: G = G::from_u64(256); + let __v_536: G = (__v_535 * __v_423); + let __v_537: G = G::from_u64(65536); + let __v_538: G = (__v_537 * __v_424); + let __v_539: G = G::from_u64(16777216); + let __v_540: G = (__v_539 * __v_425); + let __v_541: G = G::from_u64(4294967296); + let __v_542: G = (__v_541 * __v_426); + let __v_543: G = G::from_u64(1099511627776); + let __v_544: G = (__v_543 * __v_427); + let __v_545: G = G::from_u64(281474976710656); + let __v_546: G = (__v_545 * __v_428); + let __v_547: G = G::from_u64(72057594037927936); + let __v_548: G = (__v_547 * __v_429); + let __v_549: G = (__v_546 + __v_548); + let __v_550: G = (__v_544 + __v_549); + let __v_551: G = (__v_542 + __v_550); + let __v_552: G = (__v_540 + __v_551); + let __v_553: G = (__v_538 + __v_552); + let __v_554: G = (__v_536 + __v_553); + let __v_555: G = (__v_422 + __v_554); + let __v_556: G = G::from_u64(256); + let __v_557: G = (__v_556 * __v_442); + let __v_558: G = G::from_u64(65536); + let __v_559: G = (__v_558 * __v_443); + let __v_560: G = G::from_u64(16777216); + let __v_561: G = (__v_560 * __v_444); + let __v_562: G = G::from_u64(4294967296); + let __v_563: G = (__v_562 * __v_445); + let __v_564: G = G::from_u64(1099511627776); + let __v_565: G = (__v_564 * __v_446); + let __v_566: G = G::from_u64(281474976710656); + let __v_567: G = (__v_566 * __v_447); + let __v_568: G = G::from_u64(72057594037927936); + let __v_569: G = (__v_568 * __v_448); + let __v_570: G = (__v_567 + __v_569); + let __v_571: G = (__v_565 + __v_570); + let __v_572: G = (__v_563 + __v_571); + let __v_573: G = (__v_561 + __v_572); + let __v_574: G = (__v_559 + __v_573); + let __v_575: G = (__v_557 + __v_574); + let __v_576: G = (__v_441 + __v_575); + let __v_577: G = G::from_u64(256); + let __v_578: G = (__v_577 * __v_450); + let __v_579: G = G::from_u64(65536); + let __v_580: G = (__v_579 * __v_451); + let __v_581: G = G::from_u64(16777216); + let __v_582: G = (__v_581 * __v_452); + let __v_583: G = G::from_u64(4294967296); + let __v_584: G = (__v_583 * __v_453); + let __v_585: G = G::from_u64(1099511627776); + let __v_586: G = (__v_585 * __v_454); + let __v_587: G = G::from_u64(281474976710656); + let __v_588: G = (__v_587 * __v_455); + let __v_589: G = G::from_u64(72057594037927936); + let __v_590: G = (__v_589 * __v_456); + let __v_591: G = (__v_588 + __v_590); + let __v_592: G = (__v_586 + __v_591); + let __v_593: G = (__v_584 + __v_592); + let __v_594: G = (__v_582 + __v_593); + let __v_595: G = (__v_580 + __v_594); + let __v_596: G = (__v_578 + __v_595); + let __v_597: G = (__v_449 + __v_596); + let __v_598: G = G::from_u64(256); + let __v_599: G = (__v_598 * __v_475); + let __v_600: G = G::from_u64(65536); + let __v_601: G = (__v_600 * __v_476); + let __v_602: G = G::from_u64(16777216); + let __v_603: G = (__v_602 * __v_477); + let __v_604: G = G::from_u64(4294967296); + let __v_605: G = (__v_604 * __v_478); + let __v_606: G = G::from_u64(1099511627776); + let __v_607: G = (__v_606 * __v_479); + let __v_608: G = G::from_u64(281474976710656); + let __v_609: G = (__v_608 * __v_480); + let __v_610: G = G::from_u64(72057594037927936); + let __v_611: G = (__v_610 * __v_481); + let __v_612: G = (__v_609 + __v_611); + let __v_613: G = (__v_607 + __v_612); + let __v_614: G = (__v_605 + __v_613); + let __v_615: G = (__v_603 + __v_614); + let __v_616: G = (__v_601 + __v_615); + let __v_617: G = (__v_599 + __v_616); + let __v_618: G = (__v_474 + __v_617); + let __v_619: G = G::from_u64(256); + let __v_620: G = (__v_619 * __v_483); + let __v_621: G = G::from_u64(65536); + let __v_622: G = (__v_621 * __v_484); + let __v_623: G = G::from_u64(16777216); + let __v_624: G = (__v_623 * __v_485); + let __v_625: G = G::from_u64(4294967296); + let __v_626: G = (__v_625 * __v_486); + let __v_627: G = G::from_u64(1099511627776); + let __v_628: G = (__v_627 * __v_487); + let __v_629: G = G::from_u64(281474976710656); + let __v_630: G = (__v_629 * __v_488); + let __v_631: G = G::from_u64(72057594037927936); + let __v_632: G = (__v_631 * __v_489); + let __v_633: G = (__v_630 + __v_632); + let __v_634: G = (__v_628 + __v_633); + let __v_635: G = (__v_626 + __v_634); + let __v_636: G = (__v_624 + __v_635); + let __v_637: G = (__v_622 + __v_636); + let __v_638: G = (__v_620 + __v_637); + let __v_639: G = (__v_482 + __v_638); + let __v_640: G = G::from_u64(256); + let __v_641: G = (__v_640 * __v_497); + let __v_642: G = G::from_u64(65536); + let __v_643: G = (__v_642 * __v_498); + let __v_644: G = G::from_u64(16777216); + let __v_645: G = (__v_644 * __v_499); + let __v_646: G = G::from_u64(4294967296); + let __v_647: G = (__v_646 * __v_500); + let __v_648: G = G::from_u64(1099511627776); + let __v_649: G = (__v_648 * __v_501); + let __v_650: G = G::from_u64(281474976710656); + let __v_651: G = (__v_650 * __v_502); + let __v_652: G = G::from_u64(72057594037927936); + let __v_653: G = (__v_652 * __v_503); + let __v_654: G = (__v_651 + __v_653); + let __v_655: G = (__v_649 + __v_654); + let __v_656: G = (__v_647 + __v_655); + let __v_657: G = (__v_645 + __v_656); + let __v_658: G = (__v_643 + __v_657); + let __v_659: G = (__v_641 + __v_658); + let __v_660: G = (__v_496 + __v_659); + let __v_661: G = G::from_u64(256); + let __v_662: G = (__v_661 * __v_505); + let __v_663: G = G::from_u64(65536); + let __v_664: G = (__v_663 * __v_506); + let __v_665: G = G::from_u64(16777216); + let __v_666: G = (__v_665 * __v_507); + let __v_667: G = G::from_u64(4294967296); + let __v_668: G = (__v_667 * __v_508); + let __v_669: G = G::from_u64(1099511627776); + let __v_670: G = (__v_669 * __v_509); + let __v_671: G = G::from_u64(281474976710656); + let __v_672: G = (__v_671 * __v_510); + let __v_673: G = G::from_u64(72057594037927936); + let __v_674: G = (__v_673 * __v_511); + let __v_675: G = (__v_672 + __v_674); + let __v_676: G = (__v_670 + __v_675); + let __v_677: G = (__v_668 + __v_676); + let __v_678: G = (__v_666 + __v_677); + let __v_679: G = (__v_664 + __v_678); + let __v_680: G = (__v_662 + __v_679); + let __v_681: G = (__v_504 + __v_680); + let __v_682: G = G::from_u64(0); + let __v_683: G = G::from_u64(0); + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_682, __v_683, __v_358, __v_534, __v_555, __v_576, __v_597]; 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_684: G = __r_arr[0]; + let __v_685: G = __r_arr[1]; + let __v_686: G = G::from_u64(0); + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_361, __v_362, __v_34, __v_30, __v_66, __v_68, __v_63, __v_64, __v_61, __v_686, __v_684, __v_685, __v_534, __v_555, __v_576, __v_597, __v_618, __v_639, __v_660, __v_681]; 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_687: G = __r_arr[0]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_688: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; - let __v_737: G = __r_arr[0]; - let __v_738: G = G::from_u64(1); - let __v_739: G = G::from_u64(1); - let __v_740: G = { let __values: [G; 3] = [__v_738, __v_739, __v_739]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_689: G = __r_arr[0]; + let __v_690: G = G::from_u64(1); + let __v_691: G = G::from_u64(1); + let __v_692: G = { let __values: [G; 3] = [__v_690, __v_691, __v_691]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_63.as_canonical_u64() { 0u64 => { - break '__mc_3 [__v_740]; + break '__mc_3 [__v_692]; }, 1u64 => { - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_64, __v_740]; 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_741: G = __r_arr[0]; - break '__mc_3 [__v_741]; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_64, __v_692]; 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_693: G = __r_arr[0]; + break '__mc_3 [__v_693]; }, _ => { return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64())); }, } }; - let __v_741: G = __mc_out___mc_3[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_61, __v_741]; let __cu = unconstrained; 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_742: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_68, __v_742]; 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_743: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_66, __v_743]; 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_744: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_560, __v_744]; 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_745: G = __r_arr[0]; - let __v_746: G = G::from_u64(1); - let __v_747: G = G::from_u64(1); - let __v_748: G = { let __values: [G; 3] = [__v_746, __v_747, __v_747]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_745, __v_748]; 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_749: G = __r_arr[0]; - let __v_750: G = __r_arr[1]; - let __v_751: G = __r_arr[2]; - let __v_752: G = __r_arr[3]; - let __v_753: G = __r_arr[4]; - let __v_754: G = __r_arr[5]; - let __v_755: G = __r_arr[6]; - let __v_756: G = __r_arr[7]; - let __v_757: G = __r_arr[8]; - let __v_758: G = __r_arr[9]; - let __v_759: G = __r_arr[10]; - let __v_760: G = __r_arr[11]; - let __v_761: G = __r_arr[12]; - let __v_762: G = __r_arr[13]; - let __v_763: G = __r_arr[14]; - let __v_764: G = __r_arr[15]; - let __v_765: G = __r_arr[16]; - let __v_766: G = __r_arr[17]; - let __v_767: G = G::from_u64(256); - let __v_768: G = (__v_767 * __v_750); - let __v_769: G = G::from_u64(65536); - let __v_770: G = (__v_769 * __v_751); - let __v_771: G = G::from_u64(16777216); - let __v_772: G = (__v_771 * __v_752); - let __v_773: G = G::from_u64(4294967296); - let __v_774: G = (__v_773 * __v_753); - let __v_775: G = G::from_u64(1099511627776); - let __v_776: G = (__v_775 * __v_754); - let __v_777: G = G::from_u64(281474976710656); - let __v_778: G = (__v_777 * __v_755); - let __v_779: G = G::from_u64(72057594037927936); - let __v_780: G = (__v_779 * __v_756); - let __v_781: G = (__v_778 + __v_780); - let __v_782: G = (__v_776 + __v_781); - let __v_783: G = (__v_774 + __v_782); - let __v_784: G = (__v_772 + __v_783); - let __v_785: G = (__v_770 + __v_784); - let __v_786: G = (__v_768 + __v_785); - let __v_787: G = (__v_749 + __v_786); - let __v_788: G = G::from_u64(256); - let __v_789: G = (__v_788 * __v_758); - let __v_790: G = G::from_u64(65536); - let __v_791: G = (__v_790 * __v_759); - let __v_792: G = G::from_u64(16777216); - let __v_793: G = (__v_792 * __v_760); - let __v_794: G = G::from_u64(4294967296); - let __v_795: G = (__v_794 * __v_761); - let __v_796: G = G::from_u64(1099511627776); - let __v_797: G = (__v_796 * __v_762); - let __v_798: G = G::from_u64(281474976710656); - let __v_799: G = (__v_798 * __v_763); - let __v_800: G = G::from_u64(72057594037927936); - let __v_801: G = (__v_800 * __v_764); - let __v_802: G = (__v_799 + __v_801); - let __v_803: G = (__v_797 + __v_802); - let __v_804: G = (__v_795 + __v_803); - let __v_805: G = (__v_793 + __v_804); - let __v_806: G = (__v_791 + __v_805); - let __v_807: G = (__v_789 + __v_806); - let __v_808: G = (__v_757 + __v_807); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_765, __v_38, __v_40, __v_209]; let __cu = unconstrained; 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_809: G = __r_arr[0]; - let __v_810: G = __r_arr[1]; - let __v_811: G = G::from_u64(1); - let __v_812: G = G::from_u64(1); - let __v_813: G = { let __values: [G; 3] = [__v_811, __v_812, __v_812]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_50, __v_813]; 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_814: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_810, __v_814]; 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_815: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_815, __v_38]; 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_816: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_816, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_219]; let __cu = unconstrained; 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_817: G = __r_arr[0]; - let __v_818: G = __r_arr[1]; - let __v_819: G = (__v_737 + __v_159); - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_817, __v_818, __v_199, __v_819]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; - let __v_820: G = __r_arr[0]; - let __v_821: G = G::from_u64(0); - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_44, __v_48, __v_821, __v_199]; let __cu = unconstrained; 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_822: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_817, __v_818, __v_822, __v_787, __v_808, __v_66, __v_68, __v_61, __v_63, __v_64, __v_24, __v_26, __v_28, __v_411, __v_410, __v_34, __v_708, __v_729, __v_736, __v_159, __v_819, __v_809, __v_38, __v_50, __v_737]; let __cu = unconstrained; 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_823: G = __r_arr[0]; - let __v_824: G = G::from_u64(0); - if (__v_169 != __v_824) { - return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_824.as_canonical_u64(), msg: None }); + let __v_693: G = __mc_out___mc_3[0]; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_61, __v_693]; 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_694: G = __r_arr[0]; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_68, __v_694]; 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_695: G = __r_arr[0]; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_66, __v_695]; 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_696: G = __r_arr[0]; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_512, __v_696]; 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_697: G = __r_arr[0]; + let __v_698: G = G::from_u64(1); + let __v_699: G = G::from_u64(1); + let __v_700: G = { let __values: [G; 3] = [__v_698, __v_699, __v_699]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_697, __v_700]; 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_701: G = __r_arr[0]; + let __v_702: G = __r_arr[1]; + let __v_703: G = __r_arr[2]; + let __v_704: G = __r_arr[3]; + let __v_705: G = __r_arr[4]; + let __v_706: G = __r_arr[5]; + let __v_707: G = __r_arr[6]; + let __v_708: G = __r_arr[7]; + let __v_709: G = __r_arr[8]; + let __v_710: G = __r_arr[9]; + let __v_711: G = __r_arr[10]; + let __v_712: G = __r_arr[11]; + let __v_713: G = __r_arr[12]; + let __v_714: G = __r_arr[13]; + let __v_715: G = __r_arr[14]; + let __v_716: G = __r_arr[15]; + let __v_717: G = __r_arr[16]; + let __v_718: G = __r_arr[17]; + let __v_719: G = G::from_u64(256); + let __v_720: G = (__v_719 * __v_702); + let __v_721: G = G::from_u64(65536); + let __v_722: G = (__v_721 * __v_703); + let __v_723: G = G::from_u64(16777216); + let __v_724: G = (__v_723 * __v_704); + let __v_725: G = G::from_u64(4294967296); + let __v_726: G = (__v_725 * __v_705); + let __v_727: G = G::from_u64(1099511627776); + let __v_728: G = (__v_727 * __v_706); + let __v_729: G = G::from_u64(281474976710656); + let __v_730: G = (__v_729 * __v_707); + let __v_731: G = G::from_u64(72057594037927936); + let __v_732: G = (__v_731 * __v_708); + let __v_733: G = (__v_730 + __v_732); + let __v_734: G = (__v_728 + __v_733); + let __v_735: G = (__v_726 + __v_734); + let __v_736: G = (__v_724 + __v_735); + let __v_737: G = (__v_722 + __v_736); + let __v_738: G = (__v_720 + __v_737); + let __v_739: G = (__v_701 + __v_738); + let __v_740: G = G::from_u64(256); + let __v_741: G = (__v_740 * __v_710); + let __v_742: G = G::from_u64(65536); + let __v_743: G = (__v_742 * __v_711); + let __v_744: G = G::from_u64(16777216); + let __v_745: G = (__v_744 * __v_712); + let __v_746: G = G::from_u64(4294967296); + let __v_747: G = (__v_746 * __v_713); + let __v_748: G = G::from_u64(1099511627776); + let __v_749: G = (__v_748 * __v_714); + let __v_750: G = G::from_u64(281474976710656); + let __v_751: G = (__v_750 * __v_715); + let __v_752: G = G::from_u64(72057594037927936); + let __v_753: G = (__v_752 * __v_716); + let __v_754: G = (__v_751 + __v_753); + let __v_755: G = (__v_749 + __v_754); + let __v_756: G = (__v_747 + __v_755); + let __v_757: G = (__v_745 + __v_756); + let __v_758: G = (__v_743 + __v_757); + let __v_759: G = (__v_741 + __v_758); + let __v_760: G = (__v_709 + __v_759); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_717, __v_38, __v_40, __v_209]; 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_761: G = __r_arr[0]; + let __v_762: G = __r_arr[1]; + let __v_763: G = G::from_u64(1); + let __v_764: G = G::from_u64(1); + let __v_765: G = { let __values: [G; 3] = [__v_763, __v_764, __v_764]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_50, __v_765]; 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_766: G = __r_arr[0]; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_762, __v_766]; 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_767: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_767, __v_38]; 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_768: G = __r_arr[0]; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_768, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_219]; 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_769: G = __r_arr[0]; + let __v_770: G = __r_arr[1]; + let __v_771: G = (__v_689 + __v_159); + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_769, __v_770, __v_199, __v_771]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_772: G = __r_arr[0]; + let __v_773: G = G::from_u64(0); + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_44, __v_48, __v_773, __v_199]; 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_774: G = __r_arr[0]; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_769, __v_770, __v_774, __v_739, __v_760, __v_66, __v_68, __v_61, __v_63, __v_64, __v_24, __v_26, __v_28, __v_363, __v_362, __v_34, __v_660, __v_681, __v_688, __v_159, __v_771, __v_761, __v_38, __v_50, __v_689]; 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_775: G = __r_arr[0]; + let __v_776: G = G::from_u64(0); + if (__v_169 != __v_776) { + return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_776.as_canonical_u64(), msg: None }); } - let __v_825: G = G::from_u64(0); - if (__v_179 != __v_825) { - return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_825.as_canonical_u64(), msg: None }); + let __v_777: G = G::from_u64(0); + if (__v_179 != __v_777) { + return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_777.as_canonical_u64(), msg: None }); } - let __v_826: G = G::from_u64(1); - if (__v_189 != __v_826) { - return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_826.as_canonical_u64(), msg: None }); + let __v_778: G = G::from_u64(1); + if (__v_189 != __v_778) { + return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_778.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; - let __v_827: G = __r_arr[0]; - let __v_828: G = G::from_u64(1); - if (__v_827 != __v_828) { - return Err(ExecError::AssertEqMismatch { lhs: __v_827.as_canonical_u64(), rhs: __v_828.as_canonical_u64(), msg: None }); + let __v_779: G = __r_arr[0]; + let __v_780: G = G::from_u64(1); + if (__v_779 != __v_780) { + return Err(ExecError::AssertEqMismatch { lhs: __v_779.as_canonical_u64(), rhs: __v_780.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_829: G = __r_arr[0]; + let __v_781: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_256]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; - let __v_830: G = __r_arr[0]; - let __v_831: G = (__v_829 - __v_830); - let __v_832: G = G::from_bool((__v_831 == G::ZERO)); - let __v_833: G = G::from_u64(1); - if (__v_832 != __v_833) { - return Err(ExecError::AssertEqMismatch { lhs: __v_832.as_canonical_u64(), rhs: __v_833.as_canonical_u64(), msg: None }); + let __v_782: G = __r_arr[0]; + let __v_783: G = (__v_781 - __v_782); + let __v_784: G = G::from_bool((__v_783 == G::ZERO)); + let __v_785: G = G::from_u64(1); + if (__v_784 != __v_785) { + return Err(ExecError::AssertEqMismatch { lhs: __v_784.as_canonical_u64(), rhs: __v_785.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_409]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; - let __v_834: G = __r_arr[0]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_786: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_30]; 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_835: G = __r_arr[0]; - let __v_836: G = (__v_834 - __v_835); - let __v_837: G = G::from_bool((__v_836 == G::ZERO)); - let __v_838: G = G::from_u64(1); - if (__v_837 != __v_838) { - return Err(ExecError::AssertEqMismatch { lhs: __v_837.as_canonical_u64(), rhs: __v_838.as_canonical_u64(), msg: None }); + let __v_787: G = __r_arr[0]; + let __v_788: G = (__v_786 - __v_787); + let __v_789: G = G::from_bool((__v_788 == G::ZERO)); + let __v_790: G = G::from_u64(1); + if (__v_789 != __v_790) { + return Err(ExecError::AssertEqMismatch { lhs: __v_789.as_canonical_u64(), rhs: __v_790.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; - let __v_839: G = __r_arr[0]; - let __v_840: G = (__v_839 - __v_737); - let __v_841: G = G::from_bool((__v_840 == G::ZERO)); - let __v_842: G = G::from_u64(1); - if (__v_841 != __v_842) { - return Err(ExecError::AssertEqMismatch { lhs: __v_841.as_canonical_u64(), rhs: __v_842.as_canonical_u64(), msg: None }); + let __v_791: G = __r_arr[0]; + let __v_792: G = (__v_791 - __v_689); + let __v_793: G = G::from_bool((__v_792 == G::ZERO)); + let __v_794: G = G::from_u64(1); + if (__v_793 != __v_794) { + return Err(ExecError::AssertEqMismatch { lhs: __v_793.as_canonical_u64(), rhs: __v_794.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_44]; 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_843: G = __r_arr[0]; - let __v_844: G = G::from_u64(3); + let __v_795: G = __r_arr[0]; + let __v_796: G = G::from_u64(3); let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_63, __v_64]; 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_845: G = __r_arr[0]; - let __v_846: G = (__v_844 + __v_845); - if (__v_843 != __v_846) { - return Err(ExecError::AssertEqMismatch { lhs: __v_843.as_canonical_u64(), rhs: __v_846.as_canonical_u64(), msg: None }); + let __v_797: G = __r_arr[0]; + let __v_798: G = (__v_796 + __v_797); + if (__v_795 != __v_798) { + return Err(ExecError::AssertEqMismatch { lhs: __v_795.as_canonical_u64(), rhs: __v_798.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; - let __v_847: G = __r_arr[0]; - let __v_848: G = (__v_847 - __v_737); - let __v_849: G = G::from_bool((__v_848 == G::ZERO)); - let __v_850: G = G::from_u64(1); - if (__v_849 != __v_850) { - return Err(ExecError::AssertEqMismatch { lhs: __v_849.as_canonical_u64(), rhs: __v_850.as_canonical_u64(), msg: None }); + let __v_799: G = __r_arr[0]; + let __v_800: G = (__v_799 - __v_689); + let __v_801: G = G::from_bool((__v_800 == G::ZERO)); + let __v_802: G = G::from_u64(1); + if (__v_801 != __v_802) { + return Err(ExecError::AssertEqMismatch { lhs: __v_801.as_canonical_u64(), rhs: __v_802.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_50]; 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_851: G = __r_arr[0]; - let __v_852: G = G::from_u64(1); - if (__v_851 != __v_852) { - return Err(ExecError::AssertEqMismatch { lhs: __v_851.as_canonical_u64(), rhs: __v_852.as_canonical_u64(), msg: None }); + let __v_803: G = __r_arr[0]; + let __v_804: G = G::from_u64(1); + if (__v_803 != __v_804) { + return Err(ExecError::AssertEqMismatch { lhs: __v_803.as_canonical_u64(), rhs: __v_804.as_canonical_u64(), msg: None }); } - let __v_853: G = G::from_u64(33); - let __v_854: G = { let __a_val = __v_819.as_canonical_u64(); let __b_val = __v_853.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __v_855: G = G::from_u64(1); - if (__v_854 != __v_855) { - return Err(ExecError::AssertEqMismatch { lhs: __v_854.as_canonical_u64(), rhs: __v_855.as_canonical_u64(), msg: None }); + let __v_805: G = G::from_u64(33); + let __v_806: G = { let __a_val = __v_771.as_canonical_u64(); let __b_val = __v_805.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_807: G = G::from_u64(1); + if (__v_806 != __v_807) { + return Err(ExecError::AssertEqMismatch { lhs: __v_806.as_canonical_u64(), rhs: __v_807.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_44, __v_820, __v_24, __v_26, __v_28, __v_411, __v_63, __v_64, __v_410, __v_34, __v_736, __v_159, __v_819]; let __cu = unconstrained; 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_856: G = __r_arr[0]; - let __v_857: G = G::from_u64(1); - if (__v_856 != __v_857) { - return Err(ExecError::AssertEqMismatch { lhs: __v_856.as_canonical_u64(), rhs: __v_857.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_44, __v_772, __v_24, __v_26, __v_28, __v_363, __v_63, __v_64, __v_362, __v_34, __v_688, __v_159, __v_771]; 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_808: G = __r_arr[0]; + let __v_809: G = G::from_u64(1); + if (__v_808 != __v_809) { + return Err(ExecError::AssertEqMismatch { lhs: __v_808.as_canonical_u64(), rhs: __v_809.as_canonical_u64(), msg: None }); } - let __v_858: G = G::from_u64(0); - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_48, __v_38, __v_823, __v_820, __v_858, __v_819]; let __cu = unconstrained; 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_859: G = __r_arr[0]; - break '__mc_1 [__v_859]; + let __v_810: G = G::from_u64(0); + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_48, __v_38, __v_775, __v_772, __v_810, __v_771]; 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_811: G = __r_arr[0]; + break '__mc_1 [__v_811]; }, } }, @@ -26386,240 +26130,240 @@ fn aiur_fn_241( }, } }; - let __v_409: G = __mc_out___mc_1[0]; - let __v_410: G = (__v_18 + __v_19); - if (__v_69 != __v_410) { - return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_410.as_canonical_u64(), msg: None }); - } - let __v_411: G = G::from_u64(256); - let __v_412: G = (__v_411 * __v_128); - let __v_413: G = G::from_u64(65536); - let __v_414: G = (__v_413 * __v_129); - let __v_415: G = G::from_u64(16777216); - let __v_416: G = (__v_415 * __v_130); - let __v_417: G = (__v_414 + __v_416); - let __v_418: G = (__v_412 + __v_417); - let __v_419: G = (__v_127 + __v_418); - let __v_420: G = G::from_u64(256); - let __v_421: G = (__v_420 * __v_132); - let __v_422: G = G::from_u64(65536); - let __v_423: G = (__v_422 * __v_133); - let __v_424: G = G::from_u64(16777216); - let __v_425: G = (__v_424 * __v_134); - let __v_426: G = (__v_423 + __v_425); - let __v_427: G = (__v_421 + __v_426); - let __v_428: G = (__v_131 + __v_427); - let __v_429: G = G::from_u64(256); - let __v_430: G = (__v_429 * __v_136); - let __v_431: G = G::from_u64(65536); - let __v_432: G = (__v_431 * __v_137); - let __v_433: G = G::from_u64(16777216); - let __v_434: G = (__v_433 * __v_138); - let __v_435: G = (__v_432 + __v_434); - let __v_436: G = (__v_430 + __v_435); - let __v_437: G = (__v_135 + __v_436); - let __v_438: G = G::from_u64(256); - let __v_439: G = (__v_438 * __v_140); - let __v_440: G = G::from_u64(65536); - let __v_441: G = (__v_440 * __v_141); - let __v_442: G = G::from_u64(16777216); - let __v_443: G = (__v_442 * __v_142); - let __v_444: G = (__v_441 + __v_443); - let __v_445: G = (__v_439 + __v_444); - let __v_446: G = (__v_139 + __v_445); - let __v_447: G = G::from_u64(256); - let __v_448: G = (__v_447 * __v_144); - let __v_449: G = G::from_u64(65536); - let __v_450: G = (__v_449 * __v_145); - let __v_451: G = G::from_u64(16777216); - let __v_452: G = (__v_451 * __v_146); - let __v_453: G = (__v_450 + __v_452); - let __v_454: G = (__v_448 + __v_453); - let __v_455: G = (__v_143 + __v_454); - let __v_456: G = G::from_u64(256); - let __v_457: G = (__v_456 * __v_148); - let __v_458: G = G::from_u64(65536); - let __v_459: G = (__v_458 * __v_149); - let __v_460: G = G::from_u64(16777216); - let __v_461: G = (__v_460 * __v_150); - let __v_462: G = (__v_459 + __v_461); - let __v_463: G = (__v_457 + __v_462); - let __v_464: G = (__v_147 + __v_463); - let __v_465: G = G::from_u64(256); - let __v_466: G = (__v_465 * __v_152); - let __v_467: G = G::from_u64(65536); - let __v_468: G = (__v_467 * __v_153); - let __v_469: G = G::from_u64(16777216); - let __v_470: G = (__v_469 * __v_154); - let __v_471: G = (__v_468 + __v_470); - let __v_472: G = (__v_466 + __v_471); - let __v_473: G = (__v_151 + __v_472); - let __v_474: G = G::from_u64(256); - let __v_475: G = (__v_474 * __v_156); - let __v_476: G = G::from_u64(65536); - let __v_477: G = (__v_476 * __v_157); - let __v_478: G = G::from_u64(16777216); - let __v_479: G = (__v_478 * __v_158); - let __v_480: G = (__v_477 + __v_479); - let __v_481: G = (__v_475 + __v_480); - let __v_482: G = (__v_155 + __v_481); - if (__v_419 != __v_0) { - return Err(ExecError::AssertEqMismatch { lhs: __v_419.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); - } - if (__v_428 != __v_1) { - return Err(ExecError::AssertEqMismatch { lhs: __v_428.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); - } - if (__v_437 != __v_2) { - return Err(ExecError::AssertEqMismatch { lhs: __v_437.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); - } - if (__v_446 != __v_3) { - return Err(ExecError::AssertEqMismatch { lhs: __v_446.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); - } - if (__v_455 != __v_4) { - return Err(ExecError::AssertEqMismatch { lhs: __v_455.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); - } - if (__v_464 != __v_5) { - return Err(ExecError::AssertEqMismatch { lhs: __v_464.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); - } - if (__v_473 != __v_6) { - return Err(ExecError::AssertEqMismatch { lhs: __v_473.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); - } - if (__v_482 != __v_7) { - return Err(ExecError::AssertEqMismatch { lhs: __v_482.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); + let __v_361: G = __mc_out___mc_1[0]; + let __v_362: G = (__v_18 + __v_19); + if (__v_69 != __v_362) { + return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_362.as_canonical_u64(), msg: None }); + } + let __v_363: G = G::from_u64(256); + let __v_364: G = (__v_363 * __v_128); + let __v_365: G = G::from_u64(65536); + let __v_366: G = (__v_365 * __v_129); + let __v_367: G = G::from_u64(16777216); + let __v_368: G = (__v_367 * __v_130); + let __v_369: G = (__v_366 + __v_368); + let __v_370: G = (__v_364 + __v_369); + let __v_371: G = (__v_127 + __v_370); + let __v_372: G = G::from_u64(256); + let __v_373: G = (__v_372 * __v_132); + let __v_374: G = G::from_u64(65536); + let __v_375: G = (__v_374 * __v_133); + let __v_376: G = G::from_u64(16777216); + let __v_377: G = (__v_376 * __v_134); + let __v_378: G = (__v_375 + __v_377); + let __v_379: G = (__v_373 + __v_378); + let __v_380: G = (__v_131 + __v_379); + let __v_381: G = G::from_u64(256); + let __v_382: G = (__v_381 * __v_136); + let __v_383: G = G::from_u64(65536); + let __v_384: G = (__v_383 * __v_137); + let __v_385: G = G::from_u64(16777216); + let __v_386: G = (__v_385 * __v_138); + let __v_387: G = (__v_384 + __v_386); + let __v_388: G = (__v_382 + __v_387); + let __v_389: G = (__v_135 + __v_388); + let __v_390: G = G::from_u64(256); + let __v_391: G = (__v_390 * __v_140); + let __v_392: G = G::from_u64(65536); + let __v_393: G = (__v_392 * __v_141); + let __v_394: G = G::from_u64(16777216); + let __v_395: G = (__v_394 * __v_142); + let __v_396: G = (__v_393 + __v_395); + let __v_397: G = (__v_391 + __v_396); + let __v_398: G = (__v_139 + __v_397); + let __v_399: G = G::from_u64(256); + let __v_400: G = (__v_399 * __v_144); + let __v_401: G = G::from_u64(65536); + let __v_402: G = (__v_401 * __v_145); + let __v_403: G = G::from_u64(16777216); + let __v_404: G = (__v_403 * __v_146); + let __v_405: G = (__v_402 + __v_404); + let __v_406: G = (__v_400 + __v_405); + let __v_407: G = (__v_143 + __v_406); + let __v_408: G = G::from_u64(256); + let __v_409: G = (__v_408 * __v_148); + let __v_410: G = G::from_u64(65536); + let __v_411: G = (__v_410 * __v_149); + let __v_412: G = G::from_u64(16777216); + let __v_413: G = (__v_412 * __v_150); + let __v_414: G = (__v_411 + __v_413); + let __v_415: G = (__v_409 + __v_414); + let __v_416: G = (__v_147 + __v_415); + let __v_417: G = G::from_u64(256); + let __v_418: G = (__v_417 * __v_152); + let __v_419: G = G::from_u64(65536); + let __v_420: G = (__v_419 * __v_153); + let __v_421: G = G::from_u64(16777216); + let __v_422: G = (__v_421 * __v_154); + let __v_423: G = (__v_420 + __v_422); + let __v_424: G = (__v_418 + __v_423); + let __v_425: G = (__v_151 + __v_424); + let __v_426: G = G::from_u64(256); + let __v_427: G = (__v_426 * __v_156); + let __v_428: G = G::from_u64(65536); + let __v_429: G = (__v_428 * __v_157); + let __v_430: G = G::from_u64(16777216); + let __v_431: G = (__v_430 * __v_158); + let __v_432: G = (__v_429 + __v_431); + let __v_433: G = (__v_427 + __v_432); + let __v_434: G = (__v_155 + __v_433); + if (__v_371 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_371.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); + } + if (__v_380 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_380.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); + } + if (__v_389 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_389.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); + } + if (__v_398 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_398.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); + } + if (__v_407 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_407.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); + } + if (__v_416 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_416.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); + } + if (__v_425 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_425.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); + } + if (__v_434 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_434.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_263.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_483: G = __loaded[0]; - let __v_484: G = __loaded[1]; - let __v_485: G = __loaded[2]; - let __v_486: G = G::from_u64(1); - let __v_487: G = G::from_u64(1); - if (__v_483 != __v_486) { - return Err(ExecError::AssertEqMismatch { lhs: __v_483.as_canonical_u64(), rhs: __v_486.as_canonical_u64(), msg: None }); - } - if (__v_484 != __v_487) { - return Err(ExecError::AssertEqMismatch { lhs: __v_484.as_canonical_u64(), rhs: __v_487.as_canonical_u64(), msg: None }); - } - if (__v_485 != __v_487) { - return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_487.as_canonical_u64(), msg: None }); - } - let __v_488: G = G::from_u64(256); - let __v_489: G = (__v_488 * __v_373); - let __v_490: G = G::from_u64(65536); - let __v_491: G = (__v_490 * __v_374); - let __v_492: G = G::from_u64(16777216); - let __v_493: G = (__v_492 * __v_375); - let __v_494: G = (__v_491 + __v_493); - let __v_495: G = (__v_489 + __v_494); - let __v_496: G = (__v_372 + __v_495); - let __v_497: G = G::from_u64(256); - let __v_498: G = (__v_497 * __v_377); - let __v_499: G = G::from_u64(65536); - let __v_500: G = (__v_499 * __v_378); - let __v_501: G = G::from_u64(16777216); - let __v_502: G = (__v_501 * __v_379); - let __v_503: G = (__v_500 + __v_502); - let __v_504: G = (__v_498 + __v_503); - let __v_505: G = (__v_376 + __v_504); - let __v_506: G = G::from_u64(256); - let __v_507: G = (__v_506 * __v_381); - let __v_508: G = G::from_u64(65536); - let __v_509: G = (__v_508 * __v_382); - let __v_510: G = G::from_u64(16777216); - let __v_511: G = (__v_510 * __v_383); - let __v_512: G = (__v_509 + __v_511); - let __v_513: G = (__v_507 + __v_512); - let __v_514: G = (__v_380 + __v_513); - let __v_515: G = G::from_u64(256); - let __v_516: G = (__v_515 * __v_385); - let __v_517: G = G::from_u64(65536); - let __v_518: G = (__v_517 * __v_386); - let __v_519: G = G::from_u64(16777216); - let __v_520: G = (__v_519 * __v_387); - let __v_521: G = (__v_518 + __v_520); - let __v_522: G = (__v_516 + __v_521); - let __v_523: G = (__v_384 + __v_522); - let __v_524: G = G::from_u64(256); - let __v_525: G = (__v_524 * __v_389); - let __v_526: G = G::from_u64(65536); - let __v_527: G = (__v_526 * __v_390); - let __v_528: G = G::from_u64(16777216); - let __v_529: G = (__v_528 * __v_391); - let __v_530: G = (__v_527 + __v_529); - let __v_531: G = (__v_525 + __v_530); - let __v_532: G = (__v_388 + __v_531); - let __v_533: G = G::from_u64(256); - let __v_534: G = (__v_533 * __v_393); - let __v_535: G = G::from_u64(65536); - let __v_536: G = (__v_535 * __v_394); - let __v_537: G = G::from_u64(16777216); - let __v_538: G = (__v_537 * __v_395); - let __v_539: G = (__v_536 + __v_538); - let __v_540: G = (__v_534 + __v_539); - let __v_541: G = (__v_392 + __v_540); - let __v_542: G = G::from_u64(256); - let __v_543: G = (__v_542 * __v_397); - let __v_544: G = G::from_u64(65536); - let __v_545: G = (__v_544 * __v_398); - let __v_546: G = G::from_u64(16777216); - let __v_547: G = (__v_546 * __v_399); - let __v_548: G = (__v_545 + __v_547); - let __v_549: G = (__v_543 + __v_548); - let __v_550: G = (__v_396 + __v_549); - let __v_551: G = G::from_u64(256); - let __v_552: G = (__v_551 * __v_401); - let __v_553: G = G::from_u64(65536); - let __v_554: G = (__v_553 * __v_402); - let __v_555: G = G::from_u64(16777216); - let __v_556: G = (__v_555 * __v_403); - let __v_557: G = (__v_554 + __v_556); - let __v_558: G = (__v_552 + __v_557); - let __v_559: G = (__v_400 + __v_558); - if (__v_496 != __v_8) { - return Err(ExecError::AssertEqMismatch { lhs: __v_496.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); - } - if (__v_505 != __v_9) { - return Err(ExecError::AssertEqMismatch { lhs: __v_505.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); - } - if (__v_514 != __v_10) { - return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); - } - if (__v_523 != __v_11) { - return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); - } - if (__v_532 != __v_12) { - return Err(ExecError::AssertEqMismatch { lhs: __v_532.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); - } - if (__v_541 != __v_13) { - return Err(ExecError::AssertEqMismatch { lhs: __v_541.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); - } - if (__v_550 != __v_14) { - return Err(ExecError::AssertEqMismatch { lhs: __v_550.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); - } - if (__v_559 != __v_15) { - return Err(ExecError::AssertEqMismatch { lhs: __v_559.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); - } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_407.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_560: G = __loaded[0]; - let __v_561: G = __loaded[1]; - let __v_562: G = __loaded[2]; - let __v_563: G = G::from_u64(1); - let __v_564: G = G::from_u64(1); - if (__v_560 != __v_563) { - return Err(ExecError::AssertEqMismatch { lhs: __v_560.as_canonical_u64(), rhs: __v_563.as_canonical_u64(), msg: None }); - } - if (__v_561 != __v_564) { - return Err(ExecError::AssertEqMismatch { lhs: __v_561.as_canonical_u64(), rhs: __v_564.as_canonical_u64(), msg: None }); - } - if (__v_562 != __v_564) { - return Err(ExecError::AssertEqMismatch { lhs: __v_562.as_canonical_u64(), rhs: __v_564.as_canonical_u64(), msg: None }); - } - let __v_565: G = G::from_u64(1); - if (__v_408 != __v_565) { - return Err(ExecError::AssertEqMismatch { lhs: __v_408.as_canonical_u64(), rhs: __v_565.as_canonical_u64(), msg: None }); - } - let __v_566: G = G::from_u64(1); - if (__v_409 != __v_566) { - return Err(ExecError::AssertEqMismatch { lhs: __v_409.as_canonical_u64(), rhs: __v_566.as_canonical_u64(), msg: None }); + let __v_435: G = __loaded[0]; + let __v_436: G = __loaded[1]; + let __v_437: G = __loaded[2]; + let __v_438: G = G::from_u64(1); + let __v_439: G = G::from_u64(1); + if (__v_435 != __v_438) { + return Err(ExecError::AssertEqMismatch { lhs: __v_435.as_canonical_u64(), rhs: __v_438.as_canonical_u64(), msg: None }); + } + if (__v_436 != __v_439) { + return Err(ExecError::AssertEqMismatch { lhs: __v_436.as_canonical_u64(), rhs: __v_439.as_canonical_u64(), msg: None }); + } + if (__v_437 != __v_439) { + return Err(ExecError::AssertEqMismatch { lhs: __v_437.as_canonical_u64(), rhs: __v_439.as_canonical_u64(), msg: None }); + } + let __v_440: G = G::from_u64(256); + let __v_441: G = (__v_440 * __v_325); + let __v_442: G = G::from_u64(65536); + let __v_443: G = (__v_442 * __v_326); + let __v_444: G = G::from_u64(16777216); + let __v_445: G = (__v_444 * __v_327); + let __v_446: G = (__v_443 + __v_445); + let __v_447: G = (__v_441 + __v_446); + let __v_448: G = (__v_324 + __v_447); + let __v_449: G = G::from_u64(256); + let __v_450: G = (__v_449 * __v_329); + let __v_451: G = G::from_u64(65536); + let __v_452: G = (__v_451 * __v_330); + let __v_453: G = G::from_u64(16777216); + let __v_454: G = (__v_453 * __v_331); + let __v_455: G = (__v_452 + __v_454); + let __v_456: G = (__v_450 + __v_455); + let __v_457: G = (__v_328 + __v_456); + let __v_458: G = G::from_u64(256); + let __v_459: G = (__v_458 * __v_333); + let __v_460: G = G::from_u64(65536); + let __v_461: G = (__v_460 * __v_334); + let __v_462: G = G::from_u64(16777216); + let __v_463: G = (__v_462 * __v_335); + let __v_464: G = (__v_461 + __v_463); + let __v_465: G = (__v_459 + __v_464); + let __v_466: G = (__v_332 + __v_465); + let __v_467: G = G::from_u64(256); + let __v_468: G = (__v_467 * __v_337); + let __v_469: G = G::from_u64(65536); + let __v_470: G = (__v_469 * __v_338); + let __v_471: G = G::from_u64(16777216); + let __v_472: G = (__v_471 * __v_339); + let __v_473: G = (__v_470 + __v_472); + let __v_474: G = (__v_468 + __v_473); + let __v_475: G = (__v_336 + __v_474); + let __v_476: G = G::from_u64(256); + let __v_477: G = (__v_476 * __v_341); + let __v_478: G = G::from_u64(65536); + let __v_479: G = (__v_478 * __v_342); + let __v_480: G = G::from_u64(16777216); + let __v_481: G = (__v_480 * __v_343); + let __v_482: G = (__v_479 + __v_481); + let __v_483: G = (__v_477 + __v_482); + let __v_484: G = (__v_340 + __v_483); + let __v_485: G = G::from_u64(256); + let __v_486: G = (__v_485 * __v_345); + let __v_487: G = G::from_u64(65536); + let __v_488: G = (__v_487 * __v_346); + let __v_489: G = G::from_u64(16777216); + let __v_490: G = (__v_489 * __v_347); + let __v_491: G = (__v_488 + __v_490); + let __v_492: G = (__v_486 + __v_491); + let __v_493: G = (__v_344 + __v_492); + let __v_494: G = G::from_u64(256); + let __v_495: G = (__v_494 * __v_349); + let __v_496: G = G::from_u64(65536); + let __v_497: G = (__v_496 * __v_350); + let __v_498: G = G::from_u64(16777216); + let __v_499: G = (__v_498 * __v_351); + let __v_500: G = (__v_497 + __v_499); + let __v_501: G = (__v_495 + __v_500); + let __v_502: G = (__v_348 + __v_501); + let __v_503: G = G::from_u64(256); + let __v_504: G = (__v_503 * __v_353); + let __v_505: G = G::from_u64(65536); + let __v_506: G = (__v_505 * __v_354); + let __v_507: G = G::from_u64(16777216); + let __v_508: G = (__v_507 * __v_355); + let __v_509: G = (__v_506 + __v_508); + let __v_510: G = (__v_504 + __v_509); + let __v_511: G = (__v_352 + __v_510); + if (__v_448 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_448.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); + } + if (__v_457 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_457.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); + } + if (__v_466 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); + } + if (__v_475 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_475.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); + } + if (__v_484 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_484.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); + } + if (__v_493 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_493.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); + } + if (__v_502 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_502.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); + } + if (__v_511 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_511.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_359.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_512: G = __loaded[0]; + let __v_513: G = __loaded[1]; + let __v_514: G = __loaded[2]; + let __v_515: G = G::from_u64(1); + let __v_516: G = G::from_u64(1); + if (__v_512 != __v_515) { + return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_515.as_canonical_u64(), msg: None }); + } + if (__v_513 != __v_516) { + return Err(ExecError::AssertEqMismatch { lhs: __v_513.as_canonical_u64(), rhs: __v_516.as_canonical_u64(), msg: None }); + } + if (__v_514 != __v_516) { + return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_516.as_canonical_u64(), msg: None }); + } + let __v_517: G = G::from_u64(1); + if (__v_360 != __v_517) { + return Err(ExecError::AssertEqMismatch { lhs: __v_360.as_canonical_u64(), rhs: __v_517.as_canonical_u64(), msg: None }); + } + let __v_518: G = G::from_u64(1); + if (__v_361 != __v_518) { + return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_518.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_241] = []; 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)); }; From 5d1c637f31fb64eff3e1972cdcd38a9cdbb33bc5 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Tue, 1 Sep 2026 22:36:05 +0000 Subject: [PATCH 29/44] Add a pinned CUDA 13.2 development shell Expose an opt-in x86_64-linux cuda shell with NVCC 13.2, sm_120 code generation, and safe host libcuda discovery while leaving the default development shell unchanged. --- flake.lock | 17 ++++++++++ flake.nix | 99 +++++++++++++++++++++++++++++++++++++++++++++--------- 2 files changed, 100 insertions(+), 16 deletions(-) diff --git a/flake.lock b/flake.lock index a18b189f8..58afa9671 100644 --- a/flake.lock +++ b/flake.lock @@ -92,6 +92,22 @@ "type": "github" } }, + "cuda-nixpkgs": { + "locked": { + "lastModified": 1787964612, + "narHash": "sha256-0N9nghg3nwzX6b6qc77EzjR9cu/Z+UR66FlfsCqiURs=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "e8be7818e19ada32105a8af937a6a473b38167ca", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, "fenix": { "inputs": { "nixpkgs": [ @@ -379,6 +395,7 @@ "inputs": { "blake3-lean": "blake3-lean", "crane": "crane_2", + "cuda-nixpkgs": "cuda-nixpkgs", "fenix": "fenix_2", "flake-parts": "flake-parts_2", "lean4-nix": "lean4-nix", diff --git a/flake.nix b/flake.nix index 9254cf0bc..d9206f5a8 100644 --- a/flake.nix +++ b/flake.nix @@ -14,6 +14,10 @@ # System packages, follows lean4-nix so we stay in sync nixpkgs.follows = "lean4-nix/nixpkgs"; + # CUDA-only packages, independently pinned so the ordinary build graph + # can retain lean4-nix's older Nixpkgs revision. + cuda-nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable"; + # Lean 4 & Lake lean4-nix.url = "github:argumentcomputer/lean4-nix"; @@ -73,6 +77,27 @@ ... }: let + # CUDA is opt-in and unfree. Its dedicated package set locks CUDA + # 13.2 without changing the default shell or ordinary package/check + # graph. + cudaPkgs = import inputs.cuda-nixpkgs { + inherit system; + config.allowUnfree = true; + }; + cudaToolkit = cudaPkgs.symlinkJoin { + name = "ix-cuda-13.2-toolkit"; + paths = [ + cudaPkgs.cudaPackages_13_2.cccl + cudaPkgs.cudaPackages_13_2.cuda_crt + cudaPkgs.cudaPackages_13_2.cuda_cudart + cudaPkgs.cudaPackages_13_2.cuda_nvcc + cudaPkgs.cudaPackages_13_2.libnvvm + ]; + postBuild = '' + ln -s lib "$out/lib64" + ''; + }; + # Pins the Lean toolchain; a plain derivation, no overlay involved lean = lean4-nix.lib.${system}.fromToolchainFile ./lean-toolchain; @@ -163,9 +188,7 @@ ./lean-toolchain ./Cargo.toml ./Cargo.lock - (pkgs.lib.fileset.fileFilter - (f: f.hasExt "rs" || f.hasExt "toml") - ./crates) + (pkgs.lib.fileset.fileFilter (f: f.hasExt "rs" || f.hasExt "toml") ./crates) (pkgs.lib.fileset.fileFilter (f: f.hasExt "lean") ./.) ]; }; @@ -328,19 +351,63 @@ ''; }; - # Lean + Rust shell for host development (`cargo build`, `lake build`). - devShells.default = pkgs.mkShell { - LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib"; - packages = with pkgs; [ - pkg-config - openssl - clang - rustToolchain - rust-analyzer - lean - cargo-deny - valgrind - ]; + devShells = { + # Lean + Rust shell for host development (`cargo build`, `lake build`). + default = pkgs.mkShell { + LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib"; + packages = with pkgs; [ + pkg-config + openssl + clang + rustToolchain + rust-analyzer + lean + cargo-deny + valgrind + ]; + }; + } + // pkgs.lib.optionalAttrs (system == "x86_64-linux") { + # CUDA stays separate so CPU development does not fetch NVIDIA's + # toolkit. Pinning NVCC/CUDA_HOME prevents a host-level + # `/usr/local/cuda` from silently selecting an incompatible + # compiler or runtime. + cuda = pkgs.mkShell { + LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib"; + NVCC = "${cudaToolkit}/bin/nvcc"; + CUDA_HOME = "${cudaToolkit}"; + CUDA_PATH = "${cudaToolkit}"; + MULTI_STARK_CUDA_ARCHS = "120"; + packages = + (with pkgs; [ + pkg-config + openssl + clang + rustToolchain + rust-analyzer + lean + cargo-deny + valgrind + ]) + ++ [ cudaToolkit ]; + shellHook = '' + export PATH="${cudaToolkit}/bin:$PATH" + export LD_LIBRARY_PATH="${cudaToolkit}/lib:${pkgs.stdenv.cc.cc.lib}/lib''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}" + + # Nix's dynamic loader does not search the host driver's + # library directory. Preload only libcuda to avoid mixing libc. + for ixCudaDriverLib in \ + /run/opengl-driver/lib/libcuda.so.1 \ + /usr/lib/x86_64-linux-gnu/libcuda.so.1 \ + /usr/lib64/libcuda.so.1; do + if [ -e "$ixCudaDriverLib" ]; then + export LD_PRELOAD="$ixCudaDriverLib''${LD_PRELOAD:+:$LD_PRELOAD}" + break + fi + done + unset ixCudaDriverLib + ''; + }; }; # TODO: Re-enable the zkVM shells once they build in CI. From df4157b5bf33ad49687d4e25fa971ac2425316ed Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Wed, 2 Sep 2026 07:12:14 -0400 Subject: [PATCH 30/44] manifest v2: measured-peaks section in the Lean reader, tree-preserving refinement emitter The Lean .ixes parser now reads the optional measured-peaks section that follows the aggregation tree (presence byte + one u64 per shard, 0 = unmeasured) and still rejects anything after the last known section; IxesManifestView carries measuredPeakBytes through pruneEmpty. ShardManifest::refine (crates/kernel/src/shard.rs) replaces some of a source manifest's leaves by their parts and leaves every other leaf untouched: records are copied from the source, part 0 keeps the leaf's id, later parts take fresh ids after the last existing one (ascending by refined leaf, then part order), each refined leaf's place in the tree becomes a balanced subtree over its parts (a source without a tree gets the Lean consumer's balancedRange first), measured peaks are carried forward, and the new partition is validated as an exact disjoint cover. rs_shard_manifest_refine exposes it; ix prove --out-ixes and the ix check --ram-budget audit both emit through it (the audit orders a split leaf's parts by block position, whatever wave settled them), replacing the flat re-derivation that dropped the tree and shifted or appended ids. Tests: 7 Rust unit tests (id policy, tree replacement, fixed point, carried peaks, rejects) and the ixes-manifest Lean suite (parser sections and strictness). Checked on a 2048-way Init partition: a leaf split under a 1 GiB budget cascades into 12 parts appended from id 2048, untouched leaves keep their claim digests, coverage holds, and re-emitting an unsplit run is byte-identical. --- Ix/Aiur/Protocol.lean | 19 ++ Ix/Cli/CheckCmd.lean | 173 +++++++++++++--- Ix/Cli/ProveCmd.lean | 30 +-- Tests/Ix/Ixes.lean | 86 ++++++++ Tests/Main.lean | 3 + crates/ffi/src/kernel.rs | 129 ++++++++++++ crates/kernel/src/shard.rs | 414 +++++++++++++++++++++++++++++++++++++ 7 files changed, 808 insertions(+), 46 deletions(-) create mode 100644 Tests/Ix/Ixes.lean diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 3db1da855..2ce609c5b 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -292,6 +292,25 @@ end AiurSystem opaque shardManifestFromPartition : @& EnvHandle → @& ByteArray → @& ByteArray → @& String → IO Unit +/-- Refine an existing `.ixes` manifest (`sourcePath`) by cutting some of + its leaves into parts and write the result to `outPath` + (`ShardManifest::refine`, `crates/kernel/src/shard.rs`). Every other + leaf keeps its block list, record, id and place in the aggregation + tree; a refined leaf's place becomes a balanced subtree over its + parts, part 0 keeps the leaf's id and later parts take fresh ids after + the last existing one. + + `refinementsBlob`: `count(u32)`, then per refined leaf `id(u32) ‖ + nparts(u32)` and per part `nblocks(u32) ‖ 32·nblocks ‖ peak(u64)`. + `measuredBlob`: empty, or one `u64` analytic prover peak per SOURCE + shard in id order; a nonzero value overrides the peak carried forward + for an unsplit leaf. The new partition is validated as an exact, + disjoint cover of the env's blocks. Returns the parts' new ids: + `count(u32)`, then per refinement `n(u32) ‖ n × id(u32)`. -/ +@[extern "rs_shard_manifest_refine"] +opaque shardManifestRefine : @& EnvHandle → @& String → + @& ByteArray → @& ByteArray → @& String → IO ByteArray + namespace Bytecode.Toplevel /-- One shard's result from `shardCheckBatchWithEnv`. `weights` is the diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 2c7894d8c..cddae9981 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -462,6 +462,10 @@ private def ixesU32 : IxesP UInt32 := do let a ← ixesU8; let b ← ixesU8; let c ← ixesU8; let d ← ixesU8 pure (a.toUInt32 ||| (b.toUInt32 <<< 8) ||| (c.toUInt32 <<< 16) ||| (d.toUInt32 <<< 24)) +private def ixesU64 : IxesP UInt64 := do + let lo ← ixesU32; let hi ← ixesU32 + pure (lo.toUInt64 ||| (hi.toUInt64 <<< 32)) + private def ixesSkip (n : Nat) : IxesP Unit := do let (b, p) ← get if p + n ≤ b.size then modify (fun _ => (b, p + n)) else throw s!"ixes: truncated (skip {n})" @@ -534,6 +538,11 @@ structure IxesManifestView where /-- Original manifest shard id for each (possibly pruned) dense array slot. -/ shardIds : Array Nat aggregationTree : AggregationTree + /-- Per dense slot, the analytic prover peak (bytes) a previous run measured + for that shard's executed record — the manifest's trailing measured-peaks + section — or `0` when it was never measured (planner output, or a manifest + written before the section existed). -/ + measuredPeakBytes : Array Nat deriving BEq, Repr private partial def ixesAggregationTree : IxesP AggregationTree := do @@ -564,8 +573,12 @@ serialized `.ixes` foreign_blocks(u32 len + 32·len) }. 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. -/ + zero presence byte) receive a balanced ascending-id fallback. After the tree + an optional measured-peaks section follows: presence byte, then one `u64` + analytic prover peak per shard in id order (`0` = unmeasured); absent on + manifests written before it existed. Anything after the last known section + is an error. Bounds-checked: a truncated/malformed file yields `.error`, + never a panic. -/ def parseIxesManifest (bytes : ByteArray) : Except String IxesManifestView := let go : IxesP IxesManifestView := do let m0 ← ixesU8; let m1 ← ixesU8; let m2 ← ixesU8; let m3 ← ixesU8 @@ -601,9 +614,22 @@ def parseIxesManifest (bytes : ByteArray) : Except String IxesManifestView := | tag => throw s!"ixes: invalid aggregation-tree presence tag {tag.toNat}" validateAggregationTree tree n.toNat let (buffer, position) ← get + let measuredPeakBytes ← if position == buffer.size then + pure (Array.replicate n.toNat 0) + else + match ← ixesU8 with + | 0 => pure (Array.replicate n.toNat 0) + | 1 => do + let mut peaks : Array Nat := #[] + for _ in [0:n.toNat] do + peaks := peaks.push (← ixesU64).toNat + pure peaks + | tag => throw s!"ixes: invalid measured-peaks presence tag {tag.toNat}" + let (buffer, position) ← get if position != buffer.size then - throw s!"ixes: {buffer.size - position} trailing bytes after aggregation tree" - pure { shards, shardIds := Array.range n.toNat, aggregationTree := tree } + throw s!"ixes: {buffer.size - position} trailing bytes after the measured-peaks section" + pure { shards, shardIds := Array.range n.toNat, aggregationTree := tree, + measuredPeakBytes } go.run' (bytes, 0) /-- Backward-compatible shard-only view used by check/prove/verify paths that @@ -702,6 +728,7 @@ def IxesManifestView.pruneEmpty (view : IxesManifestView) let mut remap : Array (Option Nat) := Array.replicate view.shards.size none let mut shards : Array (Array Address) := #[] let mut shardIds : Array Nat := #[] + let mut measuredPeakBytes : Array Nat := #[] let mut keptCounts : Array Nat := #[] for (count, oldIdx) in counts.mapIdx fun oldIdx count => (count, oldIdx) do if count != 0 then @@ -712,10 +739,11 @@ def IxesManifestView.pruneEmpty (view : IxesManifestView) remap := remap.set! oldIdx (some shards.size) shards := shards.push blocks shardIds := shardIds.push originalId + measuredPeakBytes := measuredPeakBytes.push ((view.measuredPeakBytes[oldIdx]?).getD 0) keptCounts := keptCounts.push count let some aggregationTree := view.aggregationTree.pruneAndRemap remap | throw "aggregate: manifest has no shard owning an environment constant" - pure ({ shards, shardIds, aggregationTree }, keptCounts) + pure ({ shards, shardIds, aggregationTree, measuredPeakBytes }, keptCounts) /-- The `CheckEnv` claim digest a shard's proof commits to — reconstructed deterministically from the env + the shard's owned blocks. Matches the @@ -874,21 +902,82 @@ def addrListsBlob (lists : Array (Array Address)) : ByteArray := lists.foldl (init := ByteArray.empty) fun blob l => l.foldl (fun b a => b ++ a.hash) (blob ++ l.size.toUInt32.toLEBytes) -/-- Emit the partition a run actually validated as a `.ixes` manifest, - measured peaks included — the shared tail of `ix prove --out-ixes` - and `ix check --ram-budget --out-ixes`. Skipped with a note when any - shard failed: a corrected manifest describes a fully-validated - partition. -/ -def emitCorrectedManifest (tag : String) (envHandle : Aiur.EnvHandle) - (out : String) (partition : Array (Array Address × Nat)) - (failures : Nat) : IO Unit := do +/-- One leaf of a source manifest cut into parts, as the prove and check + split loops produce it: the parts' block lists in block order, each + with the analytic prover peak measured on its executed record + (`0` = unmeasured). -/ +structure LeafRefinement where + shard : Nat + parts : Array (Array Address × Nat) + +/-- Wire encoding of `Aiur.shardManifestRefine`'s refinements argument: + `count(u32)`, then per refined leaf `id(u32) ‖ nparts(u32)` and per + part `nblocks(u32) ‖ 32·nblocks ‖ peak(u64)`. -/ +def refinementsBlob (rs : Array LeafRefinement) : ByteArray := + rs.foldl (init := rs.size.toUInt32.toLEBytes) fun blob r => + r.parts.foldl + (init := blob ++ r.shard.toUInt32.toLEBytes ++ r.parts.size.toUInt32.toLEBytes) + fun blob (blocks, peak) => + (blocks.foldl (fun b a => b ++ a.hash) (blob ++ blocks.size.toUInt32.toLEBytes)) + ++ peak.toUInt64.toLEBytes + +/-- Group per-leaf run results `(shard, parts)` over the `n` leaves of a + source manifest into the leaves that split (≥ 2 parts) and the + measured peaks of the leaves that did not (`0` where a leaf was not + run). -/ +def refinementsOfRuns (n : Nat) + (runs : Array (Nat × Array (Array Address × Nat))) : + Array LeafRefinement × Array Nat := + runs.foldl (init := (#[], Array.replicate n 0)) fun (rs, measured) (k, parts) => + if parts.size > 1 then (rs.push { shard := k, parts }, measured) + else match parts[0]? with + | some (_, peak) => (rs, if k < measured.size then measured.set! k peak else measured) + | none => (rs, measured) + +/-- Decode the new-id table `Aiur.shardManifestRefine` returns: + `count(u32)`, then per refinement `n(u32) ‖ n × id(u32)`. Malformed + input yields the ids decoded so far, never a panic. -/ +def decodeIdTable (bytes : ByteArray) : Array (Array Nat) := Id.run do + let u32At (i : Nat) : Option Nat := + if i + 4 ≤ bytes.size then + some (bytes[i]!.toNat ||| (bytes[i+1]!.toNat <<< 8) + ||| (bytes[i+2]!.toNat <<< 16) ||| (bytes[i+3]!.toNat <<< 24)) + else none + let some count := u32At 0 | return #[] + let mut pos := 4 + let mut table : Array (Array Nat) := #[] + for _ in [0:count] do + let some n := u32At pos | return table + pos := pos + 4 + let mut ids : Array Nat := #[] + for _ in [0:n] do + let some id := u32At pos | return table + ids := ids.push id + pos := pos + 4 + table := table.push ids + return table + +/-- Emit the partition a run actually validated as a refinement of the + manifest it started from — the shared tail of `ix prove --out-ixes` + and `ix check --ram-budget --out-ixes`. Untouched leaves keep their + records, ids and tree positions (`Aiur.shardManifestRefine`); a leaf + that split becomes a subtree over its parts, part 0 keeping the leaf's + id and later parts taking fresh ids after the last existing one. + `measured` carries the peaks of the leaves that ran unsplit. Skipped + with a note when any shard failed: a refined manifest describes a + fully-validated partition. Returns the parts' new ids per refinement. -/ +def emitRefinedManifest (tag : String) (envHandle : Aiur.EnvHandle) + (sourcePath out : String) (refinements : Array LeafRefinement) + (measured : Array Nat) (failures : Nat) : IO (Array (Array Nat)) := do if failures == 0 then - Aiur.shardManifestFromPartition envHandle - (addrListsBlob (partition.map (·.1))) - (peaksBlob (partition.map (·.2))) out - IO.println s!"[{tag}] corrected manifest → {out}" + let ids ← Aiur.shardManifestRefine envHandle sourcePath + (refinementsBlob refinements) (peaksBlob measured) out + IO.println s!"[{tag}] refined manifest → {out} \ + ({refinements.size} leaf/leaves split)" + pure (decodeIdTable ids) else IO.eprintln s!"--out-ixes {out} skipped: {failures} failure(s)" + pure #[] /-- Whole-partition check as ONE Rust rayon batch: work-stealing across shards, no chunk barriers (measured 2.3–2.5x faster than the @@ -925,11 +1014,11 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) let checkConstIdx := (compiled.getFuncIdx `check_const).getD 0 if profileOut.isSome && (compiled.getFuncIdx `check_const).isNone then IO.eprintln "--profile: no `check_const` in compiled toplevel" - let cutLabeled (label : String) (blocks owned : Array Address) - (p : Nat) : Array (String × Array Address × Array Address) := + let cutLabeled (origin : Nat) (label : String) (blocks owned : Array Address) + (p : Nat) : Array (Nat × String × Array Address × Array Address) := let parts := cutBlocks blocks p (parts.zip (partitionOwned ixonEnv owned parts)).mapIdx - fun i (part, po) => (s!"{label}.{i}", part, po) + fun i (part, po) => (origin, s!"{label}.{i}", part, po) -- One loop over execution waves. Wave 0 is the planned partition; -- with `--ram-budget` every over-budget shard is cut into the peak -- model's suggested part count and the parts re-batched as the next @@ -941,12 +1030,15 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) -- The whole run's ownership assignment: one env pass here, and -- every later wave's parts inherit their parent's owned consts via -- `partitionOwned` — no wave ever rescans the env. - let mut wave : Array (String × Array Address × Array Address) := + let mut wave : Array (Nat × String × Array Address × Array Address) := (shards.zip (ownedConstsPer ixonEnv shards)).mapIdx - fun k (b, o) => (s!"{k}", b, o) + fun k (b, o) => (k, s!"{k}", b, o) let mut waveNum := 0 let mut failed : Array String := #[] let mut final : Array (Array Address × Nat) := #[] + -- Per source leaf, the parts that ended its cascade (fit, or failed) + -- — the refinement the emitted manifest describes. + let mut leafParts : Std.HashMap Nat (Array (Array Address × Nat)) := {} let mut totalConsts := 0 let mut elapsedMs := 0 while wave.size > 0 do @@ -956,7 +1048,7 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) else IO.println s!"[wave {waveNum}] re-executing {wave.size} part(s)" (← IO.getStdout).flush - let ownedPer := wave.map (·.2.2) + let ownedPer := wave.map (·.2.2.2) let start ← IO.monoMsNow match compiled.bytecode.shardCheckBatchWithEnv funIdx envHandle (addrListsBlob ownedPer) useBytecode jobs @@ -970,25 +1062,28 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) -- extras outside the benchmarked engine window. elapsedMs := (← IO.monoMsNow) - start totalConsts := ownedPer.foldl (· + ·.size) 0 - let mut next : Array (String × Array Address × Array Address) := #[] - for (r, label, blocks, owned) in rs.zip wave do + let mut next : Array (Nat × String × Array Address × Array Address) := #[] + for (r, origin, label, blocks, owned) in rs.zip wave do let gib := toGib r.peakBytes + let settled := r.error.isEmpty && r.suggestedParts <= 1 + || !r.error.isEmpty || blocks.size <= 1 if !r.error.isEmpty then IO.eprintln s!"[shard {label}] FAILED: {r.error}" failed := failed.push s!"shard {label}: {r.error}" - final := final.push (blocks, r.peakBytes) else if r.suggestedParts <= 1 then IO.println s!"[shard {label}] ok, projected prover peak {gib} GiB" - final := final.push (blocks, r.peakBytes) else if blocks.size <= 1 then IO.eprintln s!"[shard {label}] peak {gib} GiB over budget and a \ single block — cannot split" failed := failed.push s!"shard {label}: single block over budget" - final := final.push (blocks, r.peakBytes) else IO.println s!"[shard {label}] peak {gib} GiB over budget — cut \ into {r.suggestedParts}" - next := next ++ cutLabeled label blocks owned r.suggestedParts + next := next ++ cutLabeled origin label blocks owned r.suggestedParts + if settled then + final := final.push (blocks, r.peakBytes) + leafParts := leafParts.insert origin + ((leafParts.getD origin #[]).push (blocks, r.peakBytes)) -- Weight rows are appended once, from wave 0: Rust already -- reduced each shard's record under its own task, so nothing -- here holds a record alive. @@ -1016,10 +1111,24 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) if failed.isEmpty && n1 < final.size then IO.println s!"[split-audit] measured total {toGib sum} GiB — \ {n1} shard(s) would fit the budget: re-shard with --shards {n1}" - -- The recalibrated partition — what this run actually validated — - -- written as the manifest the next run should start from. + -- The refined partition — what this run actually validated — written + -- as a refinement of the manifest it started from: untouched leaves + -- keep their records, ids and tree positions, and a split leaf's parts + -- are ordered by their position in the leaf's block list, whatever + -- wave settled them. if let some out := outIxes then - emitCorrectedManifest "split-audit" envHandle out final failed.size + let runs : Array (Nat × Array (Array Address × Nat)) := + (Array.range shards.size).filterMap fun k => + (leafParts.get? k).map fun parts => + let pos : Std.HashMap Address Nat := + ((shards[k]!).mapIdx fun i a => (a, i)).foldl + (fun m (a, i) => m.insert a i) {} + let posOf (part : Array Address × Nat) : Nat := + ((part.1[0]?).bind pos.get?).getD 0 + (k, parts.qsort fun a b => posOf a < posOf b) + let (refinements, measured) := refinementsOfRuns shards.size runs + let _ ← emitRefinedManifest "split-audit" envHandle manifestPath out + refinements measured failed.size -- One env-keyed results row for `ix bench run --backend aiur-sharded-env`: -- the measured window is the wave-0 batch FFI call (env load and -- blob setup are excluded, matching what the benchmark tracks — the diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index ff4e0fefa..872552997 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -230,13 +230,16 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let execOnly := p.hasFlag "exec-only" let outIxes := (p.flag? "out-ixes").map (·.as! String) -- Both `--ixes` branches end the same way: the partition the run - -- actually proved, written as the manifest to start the next run from. - let emitCorrected (envHandle : Aiur.EnvHandle) - (partition : Array (Array Address × Nat)) (failures : Nat) : - IO Unit := do + -- actually proved, written as a refinement of the manifest it started + -- from — the one the next run of this env should start from. + let emitRefined (envHandle : Aiur.EnvHandle) (sourcePath : String) + (numShards : Nat) (runs : Array (Nat × Array (Array Address × Nat))) + (failures : Nat) : IO Unit := do if let some out := outIxes then - Ix.Cli.CheckCmd.emitCorrectedManifest "prove" envHandle out partition - failures + let (refinements, measured) := + Ix.Cli.CheckCmd.refinementsOfRuns numShards runs + let _ ← Ix.Cli.CheckCmd.emitRefinedManifest "prove" envHandle + sourcePath out refinements measured failures let ixePath : Option String := (p.flag? "ixe").map (·.as! String) let claimHex : Option String := (p.flag? "claim").map (·.as! String) let names := (p.variableArgsAs! String).toList @@ -266,12 +269,10 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do -- A single-shard run plans exactly one shard, not the whole -- partition. reportPartition parts 1 - -- The corrected whole partition: the plan with shard k replaced - -- by the parts this run actually proved (other shards stay - -- unmeasured — this run never executed them). - emitCorrected envHandle - ((shards.extract 0 k).map (·, 0) ++ parts - ++ (shards.extract (k + 1) shards.size).map (·, 0)) 0 + -- The refined whole partition: the source manifest with shard k + -- replaced by the parts this run actually proved; every other + -- leaf is carried over untouched (this run never executed them). + emitRefined envHandle manifest shards.size #[(k, parts)] 0 return 0 | some ixe, some manifest, none => -- IxVM-native all-shards prove. Same envHandle reused across @@ -287,13 +288,14 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do -- once at the end rather than rewritten per split. Ownership is -- assigned in ONE env pass here; splits inherit it. let ownedPer := Ix.Cli.CheckCmd.ownedConstsPer ixonEnv shards + let mut runs : Array (Nat × Array (Array Address × Nat)) := #[] let mut proven : Array (Array Address × Nat) := #[] let mut failed : Array String := #[] for k in [0 : shards.size] do match ← runShardProveNative envHandle ixonEnv shards ownedPer k aiurSystem compiled maxRamBytes execOnly with | .error e => IO.eprintln e; failed := failed.push e - | .ok parts => proven := proven ++ parts + | .ok parts => runs := runs.push (k, parts); proven := proven ++ parts if failed.isEmpty then reportPartition proven shards.size -- Consolidation is arithmetic from the peaks this run already @@ -311,7 +313,7 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do IO.eprintln s!"[prove] {failed.size} of {shards.size} shard(s) FAILED:" for e in failed do IO.eprintln s!" {e}" - emitCorrected envHandle proven failed.size + emitRefined envHandle manifest shards.size runs failed.size return if failed.isEmpty then 0 else 1 | _, _, _ => Ix.Cli.CheckCmd.forEachClaim ixePath claimHex names keepGoing "prove" false runOne diff --git a/Tests/Ix/Ixes.lean b/Tests/Ix/Ixes.lean new file mode 100644 index 000000000..433b000fe --- /dev/null +++ b/Tests/Ix/Ixes.lean @@ -0,0 +1,86 @@ +module + +import Ix.Cli.CheckCmd + +/-! +`.ixes` manifest parser: the optional trailing sections (bisection tree, +measured peaks) and the strict end-of-input check, on synthetic manifests +built byte by byte so no environment is needed. +-/ + +namespace Tests.Ix.Ixes + +open Ix.Cli.CheckCmd (AggregationTree parseIxesManifest) + +private def u32 (n : Nat) : ByteArray := n.toUInt32.toLEBytes +private def u64 (n : Nat) : ByteArray := n.toUInt64.toLEBytes + +private def fakeAddr (tag : UInt8) : ByteArray := + ByteArray.mk (Array.replicate 32 tag) + +/-- One shard record: `id ‖ heartbeats ‖ own_size ‖ cross_ingress ‖ + assumption_root(absent) ‖ blocks(1) ‖ foreign_blocks(0)`. -/ +private def record (id : Nat) : ByteArray := + u32 id ++ u64 (100 + id) ++ u64 (200 + id) ++ u64 0 + ++ ByteArray.mk #[0] ++ u32 1 ++ fakeAddr (id.toUInt8 + 1) ++ u32 0 + +/-- Records only: the layout every writer starts with. -/ +private def recordsOnly : ByteArray := + "IXES".toUTF8 ++ ByteArray.mk #[0, 0, 0, 0] ++ ByteArray.mk (Array.replicate 16 0) + ++ u32 2 ++ record 0 ++ record 1 + +/-- `node(leaf 1, leaf 0)`: deliberately not the balanced fallback. -/ +private def treeSection : ByteArray := + ByteArray.mk #[1, 1, 0] ++ u32 1 ++ ByteArray.mk #[0] ++ u32 0 + +private def expect (name : String) (cond : Bool) : IO Bool := do + if cond then IO.println s!" ✓ {name}" else IO.eprintln s!" ✗ {name}" + pure cond + +private def isErrorContaining (r : Except String α) (needle : String) : Bool := + match r with + | .error e => (e.splitOn needle).length > 1 + | .ok _ => false + +public def suite : IO UInt32 := do + IO.println "ixes-manifest" + let balanced := AggregationTree.node (.leaf 0) (.leaf 1) + let custom := AggregationTree.node (.leaf 1) (.leaf 0) + let mut ok := true + -- 1. Records only: balanced tree fallback, unmeasured peaks. + let r1 := parseIxesManifest recordsOnly + ok := (← expect "records-only parses" r1.toBool) && ok + if let .ok v := r1 then + ok := (← expect "records-only: two shards, one block each" + (v.shards.size == 2 && v.shards.all (·.size == 1))) && ok + ok := (← expect "records-only: balanced tree fallback" (v.aggregationTree == balanced)) && ok + ok := (← expect "records-only: peaks unmeasured" (v.measuredPeakBytes == #[0, 0])) && ok + -- 2. Explicit zero presence bytes for both sections (what `ix shard` + -- writes for a planner manifest with no tree). + let r2 := parseIxesManifest (recordsOnly ++ ByteArray.mk #[0, 0]) + ok := (← expect "zero presence bytes parse" r2.toBool) && ok + if let .ok v := r2 then + ok := (← expect "zero presence: balanced tree, zero peaks" + (v.aggregationTree == balanced && v.measuredPeakBytes == #[0, 0])) && ok + -- 3. Tree, then peaks. + let withPeaks := recordsOnly ++ treeSection ++ ByteArray.mk #[1] ++ u64 4096 ++ u64 0 + let r3 := parseIxesManifest withPeaks + ok := (← expect "tree + peaks parse" r3.toBool) && ok + if let .ok v := r3 then + ok := (← expect "tree section is honoured" (v.aggregationTree == custom)) && ok + ok := (← expect "peaks read in id order" (v.measuredPeakBytes == #[4096, 0])) && ok + -- 4. Tree, no peaks section at all (pre-peaks writer). + let r4 := parseIxesManifest (recordsOnly ++ treeSection) + ok := (← expect "tree without peaks section parses" r4.toBool) && ok + if let .ok v := r4 then + ok := (← expect "tree without peaks: zero peaks" (v.measuredPeakBytes == #[0, 0])) && ok + -- 5. Strictness: anything after the last known section is an error. + ok := (← expect "trailing byte after peaks is rejected" + (isErrorContaining (parseIxesManifest (withPeaks ++ ByteArray.mk #[7])) "trailing")) && ok + ok := (← expect "bad peaks presence tag is rejected" + (isErrorContaining (parseIxesManifest (recordsOnly ++ treeSection ++ ByteArray.mk #[2])) "presence tag")) && ok + ok := (← expect "truncated peaks section is rejected" + (isErrorContaining (parseIxesManifest (recordsOnly ++ treeSection ++ ByteArray.mk #[1] ++ u64 1)) "truncated")) && ok + pure (if ok then 0 else 1) + +end Tests.Ix.Ixes diff --git a/Tests/Main.lean b/Tests/Main.lean index 8a33983c6..331b32a66 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -57,6 +57,7 @@ import Tests.Aggr import Tests.AggrSemantics import Tests.AggrActivation import Tests.Cli +import Tests.Ix.Ixes import Tests.ShardMap import Tests.Ix.EnvBody import Tests.Ix.Lean4Lean @@ -191,6 +192,8 @@ def primaryRunners : List (String × IO UInt32) := [ -- Converged heterogeneous aggregation circuit: all ten `ix_aggr` shapes, -- driver/cache semantics, and one negative case per broken binding. ("ix-aggr", Tests.Aggr.convergedSuite), + -- `.ixes` manifest parser: trailing tree/peaks sections and strictness. + ("ixes-manifest", Tests.Ix.Ixes.suite), ] /-- Ignored test runners - expensive, deferred IO actions run only when explicitly requested -/ diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs index 3eaac26cc..5de93005a 100644 --- a/crates/ffi/src/kernel.rs +++ b/crates/ffi/src/kernel.rs @@ -2492,6 +2492,135 @@ pub extern "C" fn rs_shard_manifest_from_partition( } } +/// Decode `rs_shard_manifest_refine`'s refinements blob: `count(u32)`, then +/// per refined leaf `id(u32) ‖ nparts(u32)` and per part +/// `nblocks(u32) ‖ 32·nblocks ‖ peak(u64)`. +fn decode_refinements( + bytes: &[u8], +) -> Result, String> { + struct Cur<'a> { + b: &'a [u8], + p: usize, + } + impl<'a> Cur<'a> { + fn take(&mut self, n: usize) -> Result<&'a [u8], String> { + let end = self + .p + .checked_add(n) + .filter(|&end| end <= self.b.len()) + .ok_or("refinements blob: truncated")?; + let s = &self.b[self.p..end]; + self.p = end; + Ok(s) + } + fn u32(&mut self) -> Result { + Ok(u32::from_le_bytes(self.take(4)?.try_into().unwrap()) as usize) + } + fn u64(&mut self) -> Result { + Ok(u64::from_le_bytes(self.take(8)?.try_into().unwrap())) + } + } + let mut c = Cur { b: bytes, p: 0 }; + let count = c.u32()?; + let mut out = Vec::with_capacity(count); + for _ in 0..count { + let id = u32::try_from(c.u32()?) + .map_err(|e| format!("refinements blob: bad id: {e}"))?; + let nparts = c.u32()?; + let mut parts = Vec::with_capacity(nparts); + let mut part_peaks = Vec::with_capacity(nparts); + for _ in 0..nparts { + let nblocks = c.u32()?; + let raw = c.take(nblocks * 32)?; + parts.push( + raw + .as_chunks::<32>() + .0 + .iter() + .map(|chunk| Address::from_slice(chunk).unwrap()) + .collect(), + ); + part_peaks.push(c.u64()?); + } + out.push(ix_kernel::shard::LeafRefinement { id, parts, part_peaks }); + } + if c.p != bytes.len() { + return Err("refinements blob: trailing bytes".into()); + } + Ok(out) +} + +/// FFI: refine an existing `.ixes` manifest by cutting some of its leaves +/// into parts (`ShardManifest::refine`): every other leaf keeps its block +/// list, record, id and place in the aggregation tree; a refined leaf's +/// place becomes a balanced subtree over its parts, part 0 keeping the +/// leaf's id and later parts taking fresh ids after the last existing one. +/// `measured_blob` is empty or one `u64` analytic prover peak per SOURCE +/// shard in id order (nonzero overrides the peak carried forward for an +/// unsplit leaf). The new partition is validated as an exact, disjoint +/// cover of the env's block profile; the manifest summary goes to stderr. +/// Returns the parts' new ids: `count(u32)`, then per refinement +/// `n(u32) ‖ n × id(u32)`. +#[allow(clippy::cast_possible_truncation)] // ids and counts are u32 by construction +#[unsafe(no_mangle)] +pub extern "C" fn rs_shard_manifest_refine( + env_handle: LeanExternal< + ixvm_codegen::env_handle::EnvHandle, + LeanBorrowed<'_>, + >, + source_path: LeanString>, + refinements_blob: LeanByteArray>, + measured_blob: LeanByteArray>, + out_path: LeanString>, +) -> LeanIOResult { + let source_path = source_path.to_string(); + let out = out_path.to_string(); + let fail = |e: String| { + LeanIOResult::error_string(&format!("rs_shard_manifest_refine: {e}")) + }; + let source = match std::fs::read(&source_path) + .map_err(|e| format!("read {source_path}: {e}")) + .and_then(|bytes| ix_kernel::shard::ShardManifest::from_bytes(&bytes)) + { + Ok(m) => m, + Err(e) => return fail(e), + }; + let refinements = match decode_refinements(refinements_blob.as_bytes()) { + Ok(r) => r, + Err(e) => return fail(e), + }; + let measured: Vec = measured_blob + .as_bytes() + .as_chunks::<8>() + .0 + .iter() + .map(|c| u64::from_le_bytes(*c)) + .collect(); + let profile = static_block_profile(&env_handle.get().env); + match ix_kernel::shard::shard_manifest_refine( + &profile, + &source, + &refinements, + &measured, + &out, + ) { + Ok((summary, part_ids)) => { + eprintln!("[shard-refine] {out}: {summary}"); + let mut bytes = Vec::new(); + bytes.extend_from_slice(&(part_ids.len() as u32).to_le_bytes()); + for ids in &part_ids { + bytes.extend_from_slice(&(ids.len() as u32).to_le_bytes()); + for id in ids { + bytes.extend_from_slice(&id.to_le_bytes()); + } + } + let ids: LeanOwned = LeanByteArray::from_bytes(&bytes).into(); + LeanIOResult::ok(ids) + }, + Err(e) => fail(e), + } +} + /// FFI: dump the static block-level reference graph of a `.ixe` as text — /// `block ` per ingress unit (a Muts block or a /// standalone constant) and `edge ` per deduped diff --git a/crates/kernel/src/shard.rs b/crates/kernel/src/shard.rs index 9e49432ed..3a21a6480 100644 --- a/crates/kernel/src/shard.rs +++ b/crates/kernel/src/shard.rs @@ -335,6 +335,38 @@ impl AggNode { } } + /// A balanced binary tree over `ids`, left to right: the left half takes + /// `len / 2` leaves, exactly the shape the Lean consumer builds with + /// `AggregationTree.balancedRange` for manifests that carry no tree. + /// `None` for an empty slice. + pub fn balanced(ids: &[u32]) -> Option { + match ids { + [] => None, + [id] => Some(AggNode::Leaf(*id)), + _ => { + let (l, r) = ids.split_at(ids.len() / 2); + Some(AggNode::Internal( + Box::new(AggNode::balanced(l)?), + Box::new(AggNode::balanced(r)?), + )) + }, + } + } + + /// The tree with `Leaf(id)` replaced by a copy of `subtree`. Every other + /// node is unchanged, so an untouched sibling subtree still folds to the + /// same slot statements — and the same aggregate cache keys — as before. + pub fn replace_leaf(&self, id: u32, subtree: &AggNode) -> AggNode { + match self { + AggNode::Leaf(x) if *x == id => subtree.clone(), + AggNode::Leaf(x) => AggNode::Leaf(*x), + AggNode::Internal(l, r) => AggNode::Internal( + Box::new(l.replace_leaf(id, subtree)), + Box::new(r.replace_leaf(id, subtree)), + ), + } + } + /// Preorder serialization: `0u8, id(4)` for a leaf; `1u8, , ` for /// an internal node. fn put(&self, out: &mut Vec) { @@ -2064,6 +2096,194 @@ pub fn shard_manifest_explicit( Ok(manifest.summary()) } +/// One leaf of a source manifest cut into parts: the parts' block lists in +/// order (each a nonempty subset of the leaf's blocks) and, per part, the +/// measured prover peak (`0` = unmeasured). +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct LeafRefinement { + pub id: u32, + pub parts: Vec>, + pub part_peaks: Vec, +} + +impl ShardManifest { + /// Refine this manifest by cutting some of its leaves into parts, leaving + /// every other leaf — block list, record, and place in the aggregation + /// tree — exactly as it was. + /// + /// Id policy: part 0 of a refined leaf keeps the leaf's id; the remaining + /// parts take fresh ids after the last existing one (ascending by refined + /// leaf id, then part order), so ids stay dense and untouched shards keep + /// their numbers. Each refined leaf's place in the tree becomes a balanced + /// subtree over its parts; a source without a tree first gets the balanced + /// tree its Lean consumer would have used. `measured` (empty, or one value + /// per source shard) overrides the carried-forward peak of unsplit shards + /// where nonzero. + /// + /// The whole new partition is validated as an exact, disjoint cover of the + /// profile's blocks. Returns the refined manifest (unsealed: the caller + /// fills assumption roots) and, per refinement, its parts' new ids. + pub fn refine( + &self, + profile: &BlockProfile, + refinements: &[LeafRefinement], + measured: &[u64], + ) -> Result<(ShardManifest, Vec>), String> { + use rustc_hash::FxHashMap; + + let n = self.shards.len(); + if n == 0 { + return Err("refine: source manifest has no shards".into()); + } + for (i, sh) in self.shards.iter().enumerate() { + if sh.id as usize != i { + return Err(format!( + "refine: source shard ids are not dense (entry {i} has id {})", + sh.id + )); + } + } + if !measured.is_empty() && measured.len() != n { + return Err(format!( + "refine: measured peaks: {} values for {n} shards", + measured.len() + )); + } + let mut by_id: FxHashMap = FxHashMap::default(); + for (i, r) in refinements.iter().enumerate() { + if r.id as usize >= n { + return Err(format!( + "refine: shard {} is out of range ({n} shards)", + r.id + )); + } + if r.parts.len() < 2 { + return Err(format!( + "refine: shard {} needs at least two parts, got {}", + r.id, + r.parts.len() + )); + } + if r.part_peaks.len() != r.parts.len() { + return Err(format!( + "refine: shard {}: {} peaks for {} parts", + r.id, + r.part_peaks.len(), + r.parts.len() + )); + } + if let Some(k) = r.parts.iter().position(Vec::is_empty) { + return Err(format!("refine: shard {} part {k} is empty", r.id)); + } + if by_id.insert(r.id, i).is_some() { + return Err(format!("refine: shard {} listed twice", r.id)); + } + } + + // The new shard list in id order: slots 0..n keep their ids (part 0 of a + // refined leaf inherits the leaf's), then the extra parts are appended. + let mut new_shards: Vec<(&[Address], u64)> = Vec::with_capacity(n); + let mut part_ids: Vec> = vec![Vec::new(); refinements.len()]; + for sh in &self.shards { + match by_id.get(&sh.id) { + None => { + let carried = measured + .get(sh.id as usize) + .copied() + .filter(|&p| p != 0) + .unwrap_or(sh.measured_peak_bytes); + new_shards.push((&sh.blocks, carried)); + }, + Some(&i) => { + let r = &refinements[i]; + new_shards.push((&r.parts[0], r.part_peaks[0])); + part_ids[i].push(sh.id); + }, + } + } + let mut refined_ids: Vec = by_id.keys().copied().collect(); + refined_ids.sort_unstable(); + for id in refined_ids { + let i = by_id[&id]; + let r = &refinements[i]; + for (part, &peak) in r.parts.iter().zip(&r.part_peaks).skip(1) { + let new_id = u32::try_from(new_shards.len()) + .map_err(|_| "refine: too many shards".to_string())?; + new_shards.push((part, peak)); + part_ids[i].push(new_id); + } + } + + // Exact cover over the profile's blocks. + let block_id: FxHashMap<&Address, u32> = profile + .blocks() + .iter() + .enumerate() + .map(|(i, b)| (&b.addr, i as u32)) + .collect(); + let mut shard_of = vec![u32::MAX; profile.num_blocks()]; + for (k, (blocks, _)) in new_shards.iter().enumerate() { + for a in *blocks { + let Some(&b) = block_id.get(a) else { + return Err(format!( + "refine: shard {k}: block {} not in the env's block profile", + a.hex() + )); + }; + if shard_of[b as usize] != u32::MAX { + return Err(format!( + "refine: block {} appears in shards {} and {k}", + a.hex(), + shard_of[b as usize] + )); + } + shard_of[b as usize] = k as u32; + } + } + let uncovered = shard_of.iter().filter(|&&s| s == u32::MAX).count(); + if uncovered > 0 { + return Err(format!( + "refine: partition covers {} of {} blocks ({uncovered} missing)", + profile.num_blocks() - uncovered, + profile.num_blocks() + )); + } + + let mut manifest = + ShardManifest::build(profile, &shard_of, new_shards.len()); + for (sh, (_, peak)) in manifest.shards.iter_mut().zip(&new_shards) { + sh.measured_peak_bytes = *peak; + } + let all_ids: Vec = (0..n as u32).collect(); + let mut tree = self + .tree + .clone() + .unwrap_or_else(|| AggNode::balanced(&all_ids).expect("n > 0 leaves")); + for (r, ids) in refinements.iter().zip(&part_ids) { + let sub = AggNode::balanced(ids).expect("at least two parts"); + tree = tree.replace_leaf(r.id, &sub); + } + manifest.tree = Some(tree); + Ok((manifest, part_ids)) + } +} + +/// Refine a source manifest ([`ShardManifest::refine`]), seal the result and +/// write it to `out_path`. Returns the manifest summary and, per refinement, +/// its parts' new ids. +pub fn shard_manifest_refine( + profile: &BlockProfile, + source: &ShardManifest, + refinements: &[LeafRefinement], + measured: &[u64], + out_path: &str, +) -> Result<(String, Vec>), String> { + let (mut manifest, part_ids) = + source.refine(profile, refinements, measured)?; + seal_and_write(&mut manifest, Some(out_path))?; + Ok((manifest.summary(), part_ids)) +} + /// Like [`shard_esp`] but sized to a per-shard Zisk **cycle** budget /// (`max_cycles`) rather than a fixed shard count: grows `N` until the heaviest /// splittable shard fits the budget (see [`partition_for_cycle_cap`]). Use @@ -3180,6 +3400,200 @@ mod tests { assert_eq!(q.tree, Some(node(leaf(0), leaf(1)))); } + fn three_way() -> (BlockProfile, ShardManifest) { + let p = two_clusters(); + let shard_of = vec![0, 0, 1, 1, 2, 2]; + let tree = node(leaf(0), node(leaf(1), leaf(2))); + let mut m = ShardManifest::build(&p, &shard_of, 3).with_tree(tree); + for sh in &mut m.shards { + sh.assumption_root = + ixon::merkle::merkle_root_canonical(&sh.foreign_blocks); + } + (p, m) + } + + fn halves(blocks: &[Address]) -> Vec> { + let (a, b) = blocks.split_at(blocks.len() / 2); + vec![a.to_vec(), b.to_vec()] + } + + #[test] + fn balanced_matches_lean_balanced_range() { + fn check(t: &AggNode, ids: &[u32]) { + let mut leaves = Vec::new(); + t.collect_leaves(&mut leaves); + assert_eq!(leaves, ids); + if let AggNode::Internal(l, r) = t { + assert_eq!(l.num_leaves(), ids.len() / 2); + check(l, &ids[..ids.len() / 2]); + check(r, &ids[ids.len() / 2..]); + } else { + assert_eq!(ids.len(), 1); + } + } + assert_eq!(AggNode::balanced(&[]), None); + for n in 1..=9u32 { + let ids: Vec = (10..10 + n).collect(); + check(&AggNode::balanced(&ids).unwrap(), &ids); + } + } + + #[test] + fn replace_leaf_keeps_siblings() { + let t = node(leaf(0), node(leaf(1), leaf(2))); + let sub = node(leaf(1), leaf(3)); + assert_eq!( + t.replace_leaf(1, &sub), + node(leaf(0), node(node(leaf(1), leaf(3)), leaf(2))) + ); + assert_eq!(t.replace_leaf(7, &sub), t); + } + + #[test] + fn refine_replaces_one_leaf_keeps_others_identical() { + let (p, m) = three_way(); + let parts = halves(&m.shards[1].blocks); + let r = LeafRefinement { id: 1, parts, part_peaks: vec![10, 20] }; + let (q, ids) = m.refine(&p, &[r], &[]).unwrap(); + assert_eq!(ids, vec![vec![1, 3]]); + assert_eq!(q.num_shards, 4); + assert_eq!(q.shards.iter().map(|s| s.id).collect::>(), [0, 1, 2, 3]); + // Untouched leaves: same record, sealed the same way. + let mut sealed = q.clone(); + for sh in &mut sealed.shards { + sh.assumption_root = + ixon::merkle::merkle_root_canonical(&sh.foreign_blocks); + } + assert_eq!(sealed.shards[0], m.shards[0]); + assert_eq!(sealed.shards[2], m.shards[2]); + // The split leaf: part 0 keeps id 1, part 1 is appended as id 3. + assert_eq!(q.shards[1].blocks, m.shards[1].blocks[..1]); + assert_eq!(q.shards[3].blocks, m.shards[1].blocks[1..]); + assert_eq!(q.shards[1].measured_peak_bytes, 10); + assert_eq!(q.shards[3].measured_peak_bytes, 20); + assert_eq!( + q.tree, + Some(node(leaf(0), node(node(leaf(1), leaf(3)), leaf(2)))) + ); + // Round trip keeps the tree and the peaks. + let back = ShardManifest::from_bytes(&sealed.to_bytes()).unwrap(); + assert_eq!(back, sealed); + } + + #[test] + fn refine_id_policy_reuse_then_append() { + let (p, m) = three_way(); + let r0 = LeafRefinement { + id: 0, + parts: halves(&m.shards[0].blocks), + part_peaks: vec![0, 0], + }; + let r2 = LeafRefinement { + id: 2, + parts: halves(&m.shards[2].blocks), + part_peaks: vec![0, 0], + }; + // Order of the refinement list does not matter: fresh ids ascend by + // refined leaf id. + let (q, ids) = m.refine(&p, &[r2.clone(), r0.clone()], &[]).unwrap(); + assert_eq!(ids, vec![vec![2, 4], vec![0, 3]]); + assert_eq!(q.shards[0].blocks, r0.parts[0]); + assert_eq!(q.shards[3].blocks, r0.parts[1]); + assert_eq!(q.shards[2].blocks, r2.parts[0]); + assert_eq!(q.shards[4].blocks, r2.parts[1]); + let mut sealed = q.clone(); + for sh in &mut sealed.shards { + sh.assumption_root = + ixon::merkle::merkle_root_canonical(&sh.foreign_blocks); + } + assert_eq!(sealed.shards[1], m.shards[1]); + assert_eq!( + q.tree, + Some(node(node(leaf(0), leaf(3)), node(leaf(1), node(leaf(2), leaf(4))))) + ); + } + + #[test] + fn refine_empty_is_fixed_point_and_carries_peaks() { + let (p, mut m) = three_way(); + m.shards[1].measured_peak_bytes = 7; + let (q, ids) = m.refine(&p, &[], &[]).unwrap(); + assert!(ids.is_empty()); + let mut sealed = q; + for sh in &mut sealed.shards { + sh.assumption_root = + ixon::merkle::merkle_root_canonical(&sh.foreign_blocks); + } + assert_eq!(sealed.to_bytes(), m.to_bytes()); + // A nonzero measurement overrides a carried peak; zero keeps it. + let (q2, _) = m.refine(&p, &[], &[5, 0, 9]).unwrap(); + assert_eq!( + q2.shards.iter().map(|s| s.measured_peak_bytes).collect::>(), + [5, 7, 9] + ); + } + + #[test] + fn refine_without_source_tree_uses_balanced_range() { + let (p, mut m) = three_way(); + m.tree = None; + let r = LeafRefinement { + id: 2, + parts: halves(&m.shards[2].blocks), + part_peaks: vec![0, 0], + }; + let (q, _) = m.refine(&p, &[r], &[]).unwrap(); + // balancedRange 0 3 = node(leaf 0, node(leaf 1, leaf 2)), then leaf 2 → + // node(leaf 2, leaf 3). + assert_eq!( + q.tree, + Some(node(leaf(0), node(leaf(1), node(leaf(2), leaf(3))))) + ); + } + + #[test] + fn refine_rejects_bad_partitions() { + let (p, m) = three_way(); + let blocks = m.shards[1].blocks.clone(); + let err = |r: LeafRefinement, measured: &[u64]| { + m.refine(&p, &[r], measured).unwrap_err() + }; + let one = LeafRefinement { + id: 1, + parts: vec![blocks.clone()], + part_peaks: vec![0], + }; + assert!(err(one, &[]).contains("at least two parts")); + let oor = + LeafRefinement { id: 9, parts: halves(&blocks), part_peaks: vec![0, 0] }; + assert!(err(oor, &[]).contains("out of range")); + let foreign = LeafRefinement { + id: 1, + parts: vec![vec![blocks[0].clone()], vec![addr(200)]], + part_peaks: vec![0, 0], + }; + assert!(err(foreign, &[]).contains("not in the env's block profile")); + let dup = LeafRefinement { + id: 1, + parts: vec![vec![blocks[0].clone()], vec![blocks[0].clone()]], + part_peaks: vec![0, 0], + }; + assert!(err(dup, &[]).contains("appears in shards")); + let missing = LeafRefinement { + id: 1, + parts: vec![vec![blocks[0].clone()], vec![m.shards[0].blocks[0].clone()]], + part_peaks: vec![0, 0], + }; + let e = err(missing, &[]); + assert!(e.contains("appears in shards") || e.contains("missing"), "{e}"); + let peaks = + LeafRefinement { id: 1, parts: halves(&blocks), part_peaks: vec![0] }; + assert!(err(peaks, &[]).contains("peaks for")); + let ok = + LeafRefinement { id: 1, parts: halves(&blocks), part_peaks: vec![0, 0] }; + assert!(err(ok, &[1, 2]).contains("measured peaks")); + } + #[test] fn manifest_rejects_tree_shard_mismatch() { let p = two_clusters(); From f0da4f78bb8a8ee864dec854f25abf02ed0928fd Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Wed, 2 Sep 2026 08:21:11 -0400 Subject: [PATCH 31/44] ix shard refine: selective, tree-preserving partition refinement with a report and a proven-leaf guard MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The batch audit loop (runShardBatchNative) now takes AuditOptions: a leaf selection (K, a-b, comma lists; --shards on ix check too), a proven-leaf guard, a JSON report path, and ix shard refine's failure policy. ix shard refine --ixes M --out M2 executes the selected leaves (default: all) under --max-ram G — omitted or 0 detects 85% of MemAvailable through the new rs_aiur_detected_ram_budget FFI and fails closed when that cannot be read (--ram-budget 0 on ix check does the same) — cuts every over-budget leaf into the parts the peak model projects will fit, wave by wave, and writes the result as a refinement of the source manifest. A leaf whose claim already has a verified proof in the shard-proof index (~/.ix/cache/shard-proofs/ → wrapper address, reused only after decode, claim equality and native verification — the new Ix.Cli.ShardProofIndex) is reported proven-kept and never executed or split, whatever its peak: refinement must never orphan a proof. Failures (a single atomic block over budget, an execution error) leave their leaf unchanged, are listed in the report with the block address and constant names, and make the exit code 2; the manifest is still written. The report (--report, provisional ix-refine/0, not normative) carries the revision, command, source/out manifests with blake3 digests, budget and its source, and per leaf its status (measured | split | proven-kept | unchanged | failed), predicted peak, claim digest, and for a split leaf its parts with labels, new ids, peaks and claim digests. The consolidation hint moved from stdout into it. Checked on the 2048-way Init partition: refining leaves 7 and 9 under 1 GiB splits 7 to depth 3 (ids 2048-2058 appended) and reports 9's single-block parts (BitVec lemma proofs near 2 GiB) as failures with their names, exit 2; a manual index entry for leaf 9's claim makes the same refine keep it proven-kept without executing it. --- Ix/Aiur/Protocol.lean | 11 + Ix/Cli/CheckCmd.lean | 342 +++++++++++++++++++++++++++----- Ix/Cli/RefineCmd.lean | 115 +++++++++++ Ix/Cli/ShardCmd.lean | 6 +- Ix/Cli/ShardProofIndex.lean | 86 ++++++++ crates/ffi/src/aiur/protocol.rs | 11 + 6 files changed, 514 insertions(+), 57 deletions(-) create mode 100644 Ix/Cli/RefineCmd.lean create mode 100644 Ix/Cli/ShardProofIndex.lean diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 2ce609c5b..ce5ac1d0e 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -311,6 +311,17 @@ opaque shardManifestFromPartition : @& EnvHandle → opaque shardManifestRefine : @& EnvHandle → @& String → @& ByteArray → @& ByteArray → @& String → IO ByteArray +@[extern "rs_aiur_detected_ram_budget"] +private opaque detectedRamBudgetFFI : IO UInt64 + +/-- The prover/execution RAM budget the Rust side detects on this machine: + 85 % of `MemAvailable` (`ix_kernel::shard::RAM_USABLE_FRAC`) — the policy + the check batch's RAM gate and `ix prove --max-ram 0` use. `0` when + `/proc/meminfo` is unreadable; callers that need a budget fail closed + on it instead of running ungated. -/ +def detectedRamBudgetBytes : IO Nat := do + pure (← detectedRamBudgetFFI).toNat + namespace Bytecode.Toplevel /-- One shard's result from `shardCheckBatchWithEnv`. `weights` is the diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index cddae9981..959b4e514 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -979,6 +979,87 @@ def emitRefinedManifest (tag : String) (envHandle : Aiur.EnvHandle) IO.eprintln s!"--out-ixes {out} skipped: {failures} failure(s)" pure #[] +/-- What a batch run is asked to do beyond the plain check. -/ +structure AuditOptions where + /-- Leaves to execute in wave 0; `none` = every leaf of the manifest. -/ + selection : Option (Array Nat) := none + /-- Decide, once the env and every leaf's owned constants are loaded, + which selected leaves a verified proof already covers: they are + reported `proven-kept`, never executed and never split (the + shard-proof index guard of `ix shard refine`). Receives the env, the + leaves' block lists, their owned constants, and the selected ids. -/ + provenGuard : Option (Ixon.Env → Array (Array Address) → Array (Array Address) + → Array Nat → IO (Std.HashMap Nat Address)) := none + /-- Write the provisional JSON report (`ix-refine/0`) here. -/ + report : Option String := none + /-- `true` (`ix shard refine`): write `--out-ixes` even when some leaves + failed — they stay unchanged — and exit 2. `false` (`ix check`): skip + the manifest on any failure. -/ + emitOnFailure : Bool := false + /-- The invoking command line, recorded in the report. -/ + command : String := "" + /-- How the budget was chosen (`flag` or `detected`), for the report. -/ + budgetSource : String := "flag" + +/-- One settled part of a leaf's cascade, for the manifest and the report. -/ +structure PartReport where + label : String + blocks : Array Address + owned : Array Address + peak : Nat + error : String := "" + +/-- Claim digest of a leaf from its already-known owned constants (no env + rescan): the digest `ix prove` persists and `ix aggregate` matches on. -/ +def claimDigestOfOwned (ixonEnv : Ixon.Env) (owned : Array Address) : + Except String Address := do + let (claim, _) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees ixonEnv owned + pure (Address.blake3 (Ix.Claim.ser claim)) + +/-- `K`, `a-b`, or a comma list of those: the leaf ids a run is restricted + to, sorted and deduplicated. -/ +def parseShardSelection (s : String) : Except String (Array Nat) := do + let mut ids : Array Nat := #[] + for piece in s.splitOn "," do + let piece := piece.trimAscii.toString + if piece.isEmpty then continue + match piece.splitOn "-" with + | [one] => + let some k := one.trimAscii.toString.toNat? + | throw s!"--shards: not a shard id: `{piece}`" + ids := ids.push k + | [lo, hi] => + let some a := lo.trimAscii.toString.toNat? + | throw s!"--shards: not a range: `{piece}`" + let some b := hi.trimAscii.toString.toNat? + | throw s!"--shards: not a range: `{piece}`" + if b < a then throw s!"--shards: empty range `{piece}`" + for k in [a:b+1] do ids := ids.push k + | _ => throw s!"--shards: malformed `{piece}` (use K, a-b, or a comma list)" + if ids.isEmpty then throw "--shards: empty selection" + let sorted := ids.qsort (· < ·) + pure (sorted.foldl (fun acc k => if acc.back? == some k then acc else acc.push k) #[]) + +private def fileDigest (path : String) : IO (Option (String × Nat)) := do + try + let bytes ← IO.FS.readBinFile path + pure (some (toString (Address.blake3 bytes), bytes.size)) + catch _ => pure none + +private def gitRevision : IO String := do + try + let out ← IO.Process.output { cmd := "git", args := #["rev-parse", "HEAD"] } + pure (if out.exitCode == 0 then out.stdout.trimAscii.toString else "unknown") + catch _ => pure "unknown" + +private def fileJson (path : String) (digest : Option (String × Nat)) + (shards : Option Nat) : Lean.Json := + Lean.Json.mkObj ([("path", Lean.Json.str path)] + ++ (match digest with + | some (h, n) => [("blake3", Lean.Json.str h), ("bytes", Lean.toJson n)] + | none => []) + ++ (match shards with | some n => [("shards", Lean.toJson n)] | none => [])) + /-- Whole-partition check as ONE Rust rayon batch: work-stealing across shards, no chunk barriers (measured 2.3–2.5x faster than the per-shard Lean-task scheduler it replaced, whose chunk-of-N full @@ -989,12 +1070,17 @@ def emitRefinedManifest (tag : String) (envHandle : Aiur.EnvHandle) under it) decisions. Builds the `EnvHandle` ONCE, shared by every shard. Coverage-gates the manifest before running any shard — exit 0 has to mean "every env const was checked by some shard", same - soundness contract as `runShardCheckAll`. -/ + soundness contract as `runShardCheckAll`. + + `opts` turns the batch into an audit: a selection of leaves, the + proven-leaf guard, a JSON report, and `ix shard refine`'s failure + policy. -/ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) (compiled : Aiur.CompiledToplevel) (useBytecode : Bool) (profileOut : Option String) (json? : Option (String × String)) - (maxRamBytes : Nat) (outIxes : Option String) : + (maxRamBytes : Nat) (outIxes : Option String) + (opts : AuditOptions := {}) : IO UInt32 := do -- The row's peak-rss needs the process-tree RSS sampler running -- (`peakTreeRssBytes` reports 0 otherwise); started before the env @@ -1004,6 +1090,14 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) | .error e => IO.eprintln e; return 1 | .ok (ixonEnv, shards) => if !(← shardsCover ixonEnv shards) then return 1 + let selected : Array Nat ← match opts.selection with + | none => pure (Array.range shards.size) + | some sel => + if let some k := sel.find? (· ≥ shards.size) then + IO.eprintln s!"--shards: shard {k} out of range ({shards.size} shards)" + return 1 + pure sel + let selectedSet : Std.HashSet Nat := selected.foldl (·.insert ·) {} let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 | .ok h => pure h @@ -1014,31 +1108,42 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) let checkConstIdx := (compiled.getFuncIdx `check_const).getD 0 if profileOut.isSome && (compiled.getFuncIdx `check_const).isNone then IO.eprintln "--profile: no `check_const` in compiled toplevel" + -- The whole run's ownership assignment: one env pass here, and every + -- later wave's parts inherit their parent's owned consts via + -- `partitionOwned` — no wave ever rescans the env. + let ownedAll := ownedConstsPer ixonEnv shards + -- Leaves a verified proof already covers stay exactly as they are. + let proven : Std.HashMap Nat Address ← match opts.provenGuard with + | none => pure {} + | some guard => guard ixonEnv shards ownedAll selected + if !proven.isEmpty then + IO.println s!"[audit] {proven.size} selected leaf/leaves already have a \ + verified proof — kept unsplit" let cutLabeled (origin : Nat) (label : String) (blocks owned : Array Address) (p : Nat) : Array (Nat × String × Array Address × Array Address) := let parts := cutBlocks blocks p (parts.zip (partitionOwned ixonEnv owned parts)).mapIdx fun i (part, po) => (origin, s!"{label}.{i}", part, po) - -- One loop over execution waves. Wave 0 is the planned partition; - -- with `--ram-budget` every over-budget shard is cut into the peak - -- model's suggested part count and the parts re-batched as the next - -- wave, until everything fits or is a single block. Without a - -- budget the FFI answers 1 part everywhere and the loop is a single - -- wave — the plain batch check. Waves after the first never - -- profile: wave 0 already carries one row per constant, measured - -- under the planned partition — the one schedulers consume. - -- The whole run's ownership assignment: one env pass here, and - -- every later wave's parts inherit their parent's owned consts via - -- `partitionOwned` — no wave ever rescans the env. + -- One loop over execution waves. Wave 0 is the selected part of the + -- planned partition; with a budget every over-budget leaf is cut into + -- the peak model's suggested part count and the parts re-batched as + -- the next wave, until everything fits or is a single block. Without + -- a budget the FFI answers 1 part everywhere and the loop is a single + -- wave — the plain batch check. Waves after the first never profile: + -- wave 0 already carries one row per constant, measured under the + -- planned partition — the one schedulers consume. let mut wave : Array (Nat × String × Array Address × Array Address) := - (shards.zip (ownedConstsPer ixonEnv shards)).mapIdx - fun k (b, o) => (k, s!"{k}", b, o) + selected.filterMap fun k => + if proven.contains k then none + else (shards[k]?).bind fun b => (ownedAll[k]?).map fun o => (k, s!"{k}", b, o) + let executed := wave.size let mut waveNum := 0 let mut failed : Array String := #[] let mut final : Array (Array Address × Nat) := #[] - -- Per source leaf, the parts that ended its cascade (fit, or failed) - -- — the refinement the emitted manifest describes. - let mut leafParts : Std.HashMap Nat (Array (Array Address × Nat)) := {} + -- Per source leaf: its wave-0 peak, and the parts that ended its + -- cascade (fit, or failed) — what the manifest and the report describe. + let mut leafPeak : Std.HashMap Nat Nat := {} + let mut leafParts : Std.HashMap Nat (Array PartReport) := {} let mut totalConsts := 0 let mut elapsedMs := 0 while wave.size > 0 do @@ -1065,25 +1170,28 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) let mut next : Array (Nat × String × Array Address × Array Address) := #[] for (r, origin, label, blocks, owned) in rs.zip wave do let gib := toGib r.peakBytes - let settled := r.error.isEmpty && r.suggestedParts <= 1 - || !r.error.isEmpty || blocks.size <= 1 + if waveNum == 0 then leafPeak := leafPeak.insert origin r.peakBytes + let mut settled : Option String := none if !r.error.isEmpty then IO.eprintln s!"[shard {label}] FAILED: {r.error}" failed := failed.push s!"shard {label}: {r.error}" + settled := some r.error else if r.suggestedParts <= 1 then IO.println s!"[shard {label}] ok, projected prover peak {gib} GiB" + settled := some "" else if blocks.size <= 1 then IO.eprintln s!"[shard {label}] peak {gib} GiB over budget and a \ single block — cannot split" failed := failed.push s!"shard {label}: single block over budget" + settled := some "single block over budget" else IO.println s!"[shard {label}] peak {gib} GiB over budget — cut \ into {r.suggestedParts}" next := next ++ cutLabeled origin label blocks owned r.suggestedParts - if settled then + if let some error := settled then final := final.push (blocks, r.peakBytes) - leafParts := leafParts.insert origin - ((leafParts.getD origin #[]).push (blocks, r.peakBytes)) + leafParts := leafParts.insert origin ((leafParts.getD origin #[]).push + { label, blocks, owned, peak := r.peakBytes, error }) -- Weight rows are appended once, from wave 0: Rust already -- reduced each shard's record under its own task, so nothing -- here holds a record alive. @@ -1098,37 +1206,134 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) h.flush wave := next waveNum := waveNum + 1 + let tag := if opts.emitOnFailure then "refine" else "split-audit" + let waves := if waveNum == 0 then 0 else waveNum - 1 if maxRamBytes > 0 then - IO.println s!"[split-audit] {final.size} part(s) from {shards.size} \ - planned shard(s), {waveNum - 1} split wave(s), {failed.size} failure(s)" - -- Consolidation is arithmetic, never an execution: the measured - -- sum only shrinks as shards get coarser, so this count is a safe - -- under-count — and the next run's mandatory executions verify it - -- inline. 95%: margin for the model's +1.7% under-projection. - let sum := final.foldl (· + ·.2) 0 - let target := maxRamBytes * 95 / 100 - let n1 := max 1 ((sum + target - 1) / target) - if failed.isEmpty && n1 < final.size then - IO.println s!"[split-audit] measured total {toGib sum} GiB — \ - {n1} shard(s) would fit the budget: re-shard with --shards {n1}" + IO.println s!"[{tag}] {final.size} part(s) from {executed} executed \ + leaf/leaves ({shards.size} in the manifest), {waves} split wave(s), \ + {failed.size} failure(s)" + -- A split leaf's parts in block order, whatever wave settled them. + let sortedParts (k : Nat) (parts : Array PartReport) : Array PartReport := + let pos : Std.HashMap Address Nat := + (((shards[k]?).getD #[]).mapIdx fun i a => (a, i)).foldl + (fun m (a, i) => m.insert a i) {} + let posOf (p : PartReport) : Nat := ((p.blocks[0]?).bind pos.get?).getD 0 + parts.qsort fun a b => posOf a < posOf b -- The refined partition — what this run actually validated — written -- as a refinement of the manifest it started from: untouched leaves - -- keep their records, ids and tree positions, and a split leaf's parts - -- are ordered by their position in the leaf's block list, whatever - -- wave settled them. + -- keep their records, ids and tree positions; a failed leaf stays as + -- in the source. + let runs : Array (Nat × Array (Array Address × Nat)) := + (Array.range shards.size).filterMap fun k => + (leafParts.get? k).bind fun ps => + if ps.any (·.error != "") then none + else some (k, (sortedParts k ps).map fun p => (p.blocks, p.peak)) + let mut idTable : Array (Array Nat) := #[] + let mut wroteManifest := false if let some out := outIxes then - let runs : Array (Nat × Array (Array Address × Nat)) := - (Array.range shards.size).filterMap fun k => - (leafParts.get? k).map fun parts => - let pos : Std.HashMap Address Nat := - ((shards[k]!).mapIdx fun i a => (a, i)).foldl - (fun m (a, i) => m.insert a i) {} - let posOf (part : Array Address × Nat) : Nat := - ((part.1[0]?).bind pos.get?).getD 0 - (k, parts.qsort fun a b => posOf a < posOf b) - let (refinements, measured) := refinementsOfRuns shards.size runs - let _ ← emitRefinedManifest "split-audit" envHandle manifestPath out - refinements measured failed.size + if failed.isEmpty || opts.emitOnFailure then + let (refinements, measured) := refinementsOfRuns shards.size runs + idTable ← emitRefinedManifest tag envHandle manifestPath out + refinements measured 0 + wroteManifest := true + else + IO.eprintln s!"--out-ixes {out} skipped: {failed.size} failure(s)" + if let some reportPath := opts.report then + -- New ids per split leaf, in refinement order (ascending leaf id). + let mut newIds : Std.HashMap Nat (Array Nat) := {} + for ((k, _), ids) in (runs.filter (·.2.size > 1)).zip idTable do + newIds := newIds.insert k ids + let digestJson (owned : Array Address) : Lean.Json := + match claimDigestOfOwned ixonEnv owned with + | .ok d => Lean.Json.str (toString d) + | .error _ => Lean.Json.null + let mut leaves : Array Lean.Json := #[] + let mut failures : Array Lean.Json := #[] + for k in [0:shards.size] do + let blocks := (shards[k]?).getD #[] + let owned := (ownedAll[k]?).getD #[] + let inRun := proven.contains k || selectedSet.contains k + let base := [("id", Lean.toJson k), ("blocks", Lean.toJson blocks.size), + ("consts", Lean.toJson owned.size), + ("claim", if inRun then digestJson owned else Lean.Json.null), + ("predicted_peak_bytes", match leafPeak.get? k with + | some p => Lean.toJson p | none => Lean.Json.null)] + let status (s : String) := Lean.Json.mkObj (base ++ [("status", Lean.Json.str s)]) + if let some addr := proven.get? k then + leaves := leaves.push (Lean.Json.mkObj (base ++ + [("status", Lean.Json.str "proven-kept"), ("proof", Lean.Json.str (toString addr))])) + else if !selectedSet.contains k then + leaves := leaves.push (status "unchanged") + else match leafParts.get? k with + | none => leaves := leaves.push (status "unchanged") + | some ps => + let ps := sortedParts k ps + let anyFailed := ps.any (·.error != "") + for p in ps do + if p.error != "" then + let names := (p.owned.filterMap fun a => + (ixonEnv.addrToName.get? a).map toString).extract 0 8 + failures := failures.push (Lean.Json.mkObj ([("id", Lean.toJson k), + ("label", Lean.Json.str p.label), ("reason", Lean.Json.str p.error), + ("blocks", Lean.toJson p.blocks.size), ("consts", Lean.toJson p.owned.size), + ("predicted_peak_bytes", Lean.toJson p.peak), + ("names", Lean.toJson names)] + ++ (match p.blocks[0]? with + | some b => if p.blocks.size == 1 then [("block", Lean.Json.str (toString b))] else [] + | none => []))) + if anyFailed then + leaves := leaves.push (status "failed") + else if ps.size == 1 then + leaves := leaves.push (status "measured") + else + let ids := (newIds.get? k).getD #[] + let depth := ps.foldl (fun d p => max d ((p.label.splitOn ".").length - 1)) 0 + let parts := ps.mapIdx fun i p => Lean.Json.mkObj [ + ("id", match ids[i]? with | some id => Lean.toJson id | none => Lean.Json.null), + ("label", Lean.Json.str p.label), ("blocks", Lean.toJson p.blocks.size), + ("consts", Lean.toJson p.owned.size), + ("predicted_peak_bytes", Lean.toJson p.peak), + ("claim", digestJson p.owned)] + leaves := leaves.push (Lean.Json.mkObj (base ++ + [("status", Lean.Json.str "split"), ("depth", Lean.toJson depth), + ("parts", Lean.Json.arr parts)])) + -- Consolidation: the leaf count the measured total says would fit the + -- budget — arithmetic from measured peaks, never an execution. + let consolidation := if maxRamBytes > 0 then + let sum := final.foldl (· + ·.2) 0 + let target := maxRamBytes * 95 / 100 + Lean.toJson (max 1 ((sum + target - 1) / target)) + else Lean.Json.null + let sourceDigest ← fileDigest manifestPath + let outJson ← match outIxes with + | some out => + if wroteManifest then do + let d ← fileDigest out + let n := shards.size + idTable.foldl (fun acc ids => acc + ids.size - 1) 0 + pure (fileJson out d (some n)) + else pure Lean.Json.null + | none => pure Lean.Json.null + let envBytes ← (do + try pure (Lean.toJson (← System.FilePath.metadata ixePath).byteSize.toNat) + catch _ => pure Lean.Json.null) + let report := Lean.Json.mkObj [ + ("schema", Lean.Json.str "ix-refine/0"), + ("revision", Lean.Json.str (← gitRevision)), + ("command", Lean.Json.str opts.command), + ("env", Lean.Json.mkObj [("path", Lean.Json.str ixePath), ("bytes", envBytes)]), + ("source", fileJson manifestPath sourceDigest (some shards.size)), + ("out", outJson), + ("budget_bytes", Lean.toJson maxRamBytes), + ("budget_source", Lean.Json.str opts.budgetSource), + ("jobs", Lean.toJson jobs), + ("selected", Lean.toJson selected.size), + ("executed", Lean.toJson executed), + ("waves", Lean.toJson waves), + ("consolidation_shards", consolidation), + ("leaves", Lean.Json.arr leaves), + ("failures", Lean.Json.arr failures)] + IO.FS.writeFile reportPath (report.pretty ++ "\n") + IO.println s!"[{tag}] report → {reportPath}" -- One env-keyed results row for `ix bench run --backend aiur-sharded-env`: -- the measured window is the wave-0 batch FFI call (env load and -- blob setup are excluded, matching what the benchmark tracks — the @@ -1150,10 +1355,14 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) return 0 IO.eprintln s!"{failed.size} of {final.size} shard(s) FAILED:" for f in failed do IO.eprintln s!" {f}" - -- Under `--json` a kernel rejection is the benchmark's `rejected` - -- exit (the row is already written), same contract as `check-rs`. + -- `ix shard refine` still wrote its manifest (failed leaves unchanged): + -- exit 2 tells the operator to read the report. Under `--json` a kernel + -- rejection is the benchmark's `rejected` exit (the row is already + -- written), same contract as `check-rs`. + if opts.emitOnFailure then return 2 return if json?.isSome then Ix.Benchmark.Results.exitRejected else 1 + /-- Run the shard operation over EVERY shard — the whole-partition behavior of `--ixes` with no `--shard` (used by `prove`). Loads the env once. Returns 1 if any shard fails, else 0. -/ @@ -1276,10 +1485,31 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do | .ok c => pure c let json? := (p.flag? "json").map fun f => (f.as! String, ((p.flag? "json-name").map (·.as! String)).getD "env") + -- `--ram-budget G` gates the audit; `--ram-budget 0` detects this + -- machine's budget (85% of MemAvailable, fail closed); omitted = the + -- plain batch check, no gate. + let (maxRamBytes, budgetSource) ← match (p.flag? "ram-budget").map (·.as! Nat) with + | none => pure (0, "none") + | some g => + if g > 0 then pure (g * gibBytes, "flag") + else + let b ← Aiur.detectedRamBudgetBytes + if b == 0 then + IO.eprintln "--ram-budget 0: cannot detect MemAvailable (/proc/meminfo unreadable)" + return 1 + IO.println s!"[split-audit] budget {toGib b} GiB (detected: 85% of MemAvailable)" + pure (b, "detected") + let selection? ← match (p.flag? "shards").map (·.as! String) with + | none => pure none + | some s => match parseShardSelection s with + | .error e => IO.eprintln s!"error: {e}"; return 1 + | .ok ids => pure (some ids) return (← runShardBatchNative manifest ixe ((p.flag? "jobs").map (·.as! Nat)) compiled useBytecode profileOut json? - (((p.flag? "ram-budget").map (·.as! Nat)).getD 0 * gibBytes) - ((p.flag? "out-ixes").map (·.as! String))) + maxRamBytes ((p.flag? "out-ixes").map (·.as! String)) + { selection := selection?, report := (p.flag? "report").map (·.as! String), + command := s!"ix check --ixe {ixe} --ixes {manifest}", budgetSource }) + | _, _, _ => -- `--jobs N` (N ≠ 1) with an `--ixe` env and no `--claim` takes the -- parallel batch path: one FFI call, rayon over the target list, @@ -1316,7 +1546,9 @@ def checkCmd : Cli.Cmd := `[Cli| "json" : String; "With --ixes (no --shard): append one env-keyed results row (see Ix.Benchmark.Results) for the batch to this file — check-time, throughput, peak-rss, constants, shards. Used by `ix bench run --backend aiur-sharded-env`." "json-name" : String; "Row key for the --json row (default: `env`)." "ram-budget" : Nat; "The destination prove box's per-shard RAM budget, GiB (with --ixes, no --shard): after the batch, cut every shard whose projected prover peak exceeds the budget into the peak model's suggested part count and re-batch the parts, wave by wave, until everything fits — the exec-only split audit. Under-filled partitions get a printed suggestion (the shard count the measured total says would fit), never an extra execution: re-shard with --shards N and let the next run's mandatory executions verify it inline. Same unit and model as `ix prove --max-ram`, but no auto-detection: the budget describes the prove box the partition is destined for, not the machine running the check. Omit for a plain check." - "out-ixes" : String; "With --ram-budget: write the recalibrated partition — the block lists the wave loop actually validated, splits included — as a `.ixes` manifest to this path. Skipped if any shard failed. The manifest the next run of this env should start from." + "out-ixes" : String; "With --ram-budget: write the partition the wave loop actually validated as a refinement of the source manifest — untouched leaves keep their records, ids and aggregation-tree positions, each split leaf becomes a subtree over its parts. Skipped if any shard failed. The manifest the next run of this env should start from." + "shards" : String; "With --ixes (no --shard): restrict the batch to these leaves — `K`, `a-b`, or a comma list of those. Every other leaf is left untouched (and, with --out-ixes, carried over unchanged)." + "report" : String; "With --ixes (no --shard): write the provisional JSON audit report (`ix-refine/0`: per-leaf status, predicted peaks, claim digests, split parts with their new ids, failures) to this path." ARGS: ...names : String; "Fully-qualified Lean.Name(s) to check. With none, iterate every named constant in the env (sorted)." diff --git a/Ix/Cli/RefineCmd.lean b/Ix/Cli/RefineCmd.lean new file mode 100644 index 000000000..1e6eded30 --- /dev/null +++ b/Ix/Cli/RefineCmd.lean @@ -0,0 +1,115 @@ +/- + `ix shard refine --ixes M.ixes --out M2.ixes [--shards SEL] + [--max-ram G] [--jobs N] [--report R.json] [--no-index]`: the local + refinement of an existing partition. Every selected leaf (default: all) is + executed and its analytic prover peak measured; a leaf over the budget is + cut into the part count the peak model projects will fit and the parts + re-executed, wave by wave, until everything fits or is a single block. The + result is written as a refinement of the source manifest: untouched leaves + keep their records, ids and tree positions, and each split leaf becomes a + balanced subtree over its parts (part 0 keeps the leaf's id, later parts + take fresh ids after the last existing one). A leaf whose claim already + has a verified proof in the shard-proof index is never split, whatever its + peak: refinement must never orphan a proof. Failures leave their leaf + unchanged, are listed in the report, and make the exit code 2. +-/ +module +public import Cli +public import Ix.Common +public import Ix.Aiur.Protocol +public import Ix.Cli.CheckCmd +public import Ix.Cli.ShardProofIndex +public import Ix.IxVM +public import Ix.IxVM.Toplevel +public import Ix.IxVM.ClaimHarness + +public section + +namespace Ix.Cli.RefineCmd + +/-- The budget the refinement gates on: `--max-ram G` (GiB), or the machine's + detected 85 % of `MemAvailable` when omitted or `0`. `none` when nothing + can be detected — the caller fails closed. -/ +def resolveBudget (maxRam? : Option Nat) : IO (Option (Nat × String)) := do + match maxRam? with + | some g => if g > 0 then return some (g * gibBytes, "flag") else detect + | none => detect +where + detect : IO (Option (Nat × String)) := do + let b ← Aiur.detectedRamBudgetBytes + if b == 0 then return none + IO.println s!"[refine] budget {toGib b} GiB (detected: 85% of MemAvailable)" + pure (some (b, "detected")) + +def runShardRefineCmd (p : Cli.Parsed) : IO UInt32 := do + let some pathArg := p.positionalArg? "path" + | p.printError "error: must specify to a .ixe file"; return 1 + let ixePath := pathArg.as! String + let some manifest := (p.flag? "ixes").map (·.as! String) + | p.printError "error: --ixes is required"; return 1 + let some out := (p.flag? "out").map (·.as! String) + | p.printError "error: --out is required"; return 1 + let selection? ← match (p.flag? "shards").map (·.as! String) with + | none => pure none + | some s => match Ix.Cli.CheckCmd.parseShardSelection s with + | .error e => p.printError s!"error: {e}"; return 1 + | .ok ids => pure (some ids) + let some (maxRamBytes, budgetSource) ← resolveBudget ((p.flag? "max-ram").map (·.as! Nat)) + | p.printError "error: cannot detect MemAvailable (/proc/meminfo unreadable); pass --max-ram G" + return 1 + let jobs? := (p.flag? "jobs").map (·.as! Nat) + let report? := (p.flag? "report").map (·.as! String) + let toplevel ← match IxVM.ixVM with + | .error e => IO.eprintln s!"toplevel merging failed: {e}"; return 1 + | .ok t => pure t + let compiled ← match toplevel.compile with + | .error e => IO.eprintln s!"compilation failed: {e}"; return 1 + | .ok c => pure c + -- The proven-leaf guard: a selected leaf whose claim already has a + -- verified proof in the index is kept exactly as it is. + let guard? ← if p.hasFlag "no-index" then pure none else do + let aiurSystem := Aiur.AiurSystem.build compiled.bytecode + Aiur.defaultCommitmentParameters Aiur.defaultFriParameters + let dir ← Ix.Cli.ShardProofIndex.indexDir + pure (some fun (ixonEnv : Ixon.Env) (_ : Array (Array Address)) + (ownedAll : Array (Array Address)) (selected : Array Nat) => do + let mut kept : Std.HashMap Nat Address := {} + for k in selected do + let some owned := ownedAll[k]? | continue + match IxVM.ClaimHarness.shardCheckEnvClaimTrees ixonEnv owned with + | .error _ => continue + | .ok (claim, _) => + if let some addr ← Ix.Cli.ShardProofIndex.verifiedProof aiurSystem compiled dir claim then + IO.println s!"[refine] shard {k}: verified proof {addr} in the index — kept" + kept := kept.insert k addr + pure kept) + let command := String.intercalate " " (#["ix shard refine", ixePath, "--ixes", manifest, "--out", out] + ++ (match (p.flag? "shards").map (·.as! String) with | some s => #["--shards", s] | none => #[]) + ++ (match (p.flag? "max-ram").map (·.as! Nat) with | some g => #["--max-ram", toString g] | none => #[]) + ++ (match jobs? with | some j => #["--jobs", toString j] | none => #[]) + ++ (match report? with | some r => #["--report", r] | none => #[]) + ++ (if p.hasFlag "no-index" then #["--no-index"] else #[])).toList + Ix.Cli.CheckCmd.runShardBatchNative manifest ixePath jobs? compiled false none none + maxRamBytes (some out) + { selection := selection?, provenGuard := guard?, report := report?, + emitOnFailure := true, command, budgetSource } + +end Ix.Cli.RefineCmd + +open Ix.Cli.RefineCmd in +def shardRefineCmd : Cli.Cmd := `[Cli| + "refine" VIA runShardRefineCmd; + "Refine an existing `.ixes` partition against a prover-RAM budget: execute the selected leaves, cut every over-budget one into parts the peak model says will fit (recursively), and write the result as a refinement of the source manifest — untouched leaves keep their records, ids and aggregation-tree positions; a leaf that already has a verified proof in the shard-proof index is never split" + + FLAGS: + ixes : String; "The source `.ixes` manifest (required)." + out : String; "Where to write the refined `.ixes` manifest (required). Written even when some leaves failed (they stay unchanged; exit 2)." + shards : String; "Leaves to audit: `K`, `a-b`, or a comma list of those. Default: every leaf. Unselected leaves are carried over unchanged." + "max-ram" : Nat; "Per-shard prover-RAM budget, GiB, in `ix prove --max-ram` units. Omitted or 0: detect 85% of this machine's MemAvailable (an error if that cannot be read)." + jobs : Nat; "Rayon threads for the execution batch (default: all cores; admission is bounded by the RAM gate, not by thread count)." + report : String; "Write the provisional JSON audit report (`ix-refine/0`: per-leaf status, predicted peaks, claim digests, split parts with their new ids, failures) to this path." + "no-index"; "Do not consult `~/.ix/cache/shard-proofs`: split over-budget leaves even when a verified proof of their claim exists (testing only)." + + ARGS: + path : String; "Path to the serialized `.ixe` environment the manifest partitions." +] diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean index 3e5a4b294..e784239b1 100644 --- a/Ix/Cli/ShardCmd.lean +++ b/Ix/Cli/ShardCmd.lean @@ -36,6 +36,7 @@ public import Cli public import Ix.Common public import Ix.KernelCheck public import Ix.Cli.ConstsFile +public import Ix.Cli.RefineCmd public section @@ -195,7 +196,7 @@ def runShardCmd (p : Cli.Parsed) : IO UInt32 := do end Ix.Cli.ShardCmd -open Ix.Cli.ShardCmd in +open Ix.Cli.ShardCmd Ix.Cli.RefineCmd in def shardCmd : Cli.Cmd := `[Cli| "shard" VIA runShardCmd; "Partition a `.ixe` env into shards: static strategy by default (`--shards N`, no kernel run), or the profiled pipeline via `--profile `" @@ -214,7 +215,8 @@ def shardCmd : Cli.Cmd := `[Cli| SUBCOMMANDS: shardExtractCmd; - shardGraphCmd + shardGraphCmd; + shardRefineCmd ] end diff --git a/Ix/Cli/ShardProofIndex.lean b/Ix/Cli/ShardProofIndex.lean new file mode 100644 index 000000000..500ac2aa9 --- /dev/null +++ b/Ix/Cli/ShardProofIndex.lean @@ -0,0 +1,86 @@ +/- + The shard-proof index: `~/.ix/cache/shard-proofs/` holds + the store address of an `Ixon.Proof` wrapper whose bundled `CheckEnv` claim + has that digest. It is what lets a partially proved partition resume after + a refinement: a leaf's identity is its claim digest, never its manifest + index. An index entry is an untrusted hint — readers decode the wrapper, + compare the bundled claim with the one they expect and verify the proof + natively before reusing it, the aggregate cache's discipline. +-/ +module +public import Ix.Address +public import Ix.Aiur.Compiler +public import Ix.Aiur.Protocol +public import Ix.Claim +public import Ix.Ixon +public import Ix.Store +public import Ix.IxVM.ClaimHarness + +public section + +namespace Ix.Cli.ShardProofIndex + +/-- The index directory: the global `~/.ix/cache/shard-proofs`, or a hermetic + root for tests. -/ +def indexDir (cacheRoot? : Option System.FilePath := none) : IO System.FilePath := do + match cacheRoot? with + | some root => + let dir := root / "shard-proofs" + IO.FS.createDirAll dir + pure dir + | none => StoreIO.toIO (Store.cacheDir "shard-proofs") + +/-- Read an index entry. A missing or malformed entry is a miss, never an + error: store loading and verification happen separately. -/ +def readAddress (dir : System.FilePath) (digest : Address) : IO (Option Address) := do + let path := dir / toString digest + if !(← path.pathExists) then return none + try + let raw ← IO.FS.readFile path + pure (Address.fromString raw.trimAscii.toString) + catch _ => pure none + +/-- Atomically replace one index entry. -/ +def writeAddress (dir : System.FilePath) (digest addr : Address) : IO Unit := do + let tmp := dir / s!"{digest}.tmp" + IO.FS.writeFile tmp s!"{addr}\n" + IO.FS.rename tmp (dir / toString digest) + +/-- Native verification of a persisted shard-proof wrapper against the claim + the caller expects: the wrapper must decode, bundle exactly `expected`, + and its proof must verify under `verify_claim`'s public input for that + claim (the same check `ix verify --shard K` performs). -/ +def verifyWrapper (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) + (expected : Ix.Claim) (proofAddr : Address) : IO (Except String Unit) := do + try + let bytes ← StoreIO.toIO (Store.read proofAddr) + match Ixon.Proof.de bytes with + | .error e => pure (.error s!"wrapper {proofAddr} does not decode: {e}") + | .ok wrapper => + if wrapper.claim != expected then + return .error s!"wrapper {proofAddr} bundles a different claim" + match Aiur.Proof.ofBytesChecked wrapper.proof with + | .error e => pure (.error s!"proof {proofAddr} does not decode: {e}") + | .ok proof => + let some funIdx := compiled.getFuncIdx `verify_claim + | return .error "`verify_claim` entrypoint missing from compiled toplevel" + let input := IxVM.ClaimHarness.packedDigestKey + (Address.blake3 (Ix.Claim.ser wrapper.claim)) + match aiurSystem.verify (Aiur.buildClaim funIdx input #[]) proof with + | .ok () => pure (.ok ()) + | .error e => pure (.error s!"proof {proofAddr} does not verify: {e}") + catch e => pure (.error s!"{e}") + +/-- The address of a verified proof of `expected`, if the index has one. + An entry that fails any check is reported and treated as a miss. -/ +def verifiedProof (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) + (dir : System.FilePath) (expected : Ix.Claim) : IO (Option Address) := do + let digest := Address.blake3 (Ix.Claim.ser expected) + let some addr ← readAddress dir digest | return none + match ← verifyWrapper aiurSystem compiled expected addr with + | .ok () => pure (some addr) + | .error e => + IO.eprintln s!"[shard-proofs] index entry for {digest} ignored: {e}" + pure none + +end Ix.Cli.ShardProofIndex diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index d9198d46a..0b49320c1 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -820,6 +820,17 @@ fn exec_rss_estimate(owned_bytes: usize) -> usize { .max(owned_bytes.saturating_mul(EXEC_RSS_RATIO_PER_OWNED_BYTE)) } +/// FFI: the detected prover/execution RAM budget in bytes +/// ([`detected_ram_budget`]: [`ix_kernel::shard::RAM_USABLE_FRAC`] of +/// `MemAvailable`), or `0` when `/proc/meminfo` is unreadable — the caller +/// decides whether to fail closed. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_detected_ram_budget() +-> lean_ffi::object::LeanIOResult { + let bytes = detected_ram_budget().unwrap_or(0); + lean_ffi::object::LeanIOResult::ok(LeanOwned::box_u64(bytes as u64)) +} + /// Detected prover/execution RAM budget: /// [`ix_kernel::shard::RAM_USABLE_FRAC`] of `MemAvailable`, reserving /// the rest for the OS. `None` (no gate) when meminfo is unreadable — From 5db19c75d547526a35c23476663f614bbdb12ccb Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Wed, 2 Sep 2026 07:45:26 -0400 Subject: [PATCH 32/44] claim-addressed progress: shard-proof index, ix prove --skip-proven, ix verify --record, ix shard claims, --shards selections MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A leaf's durable identity is its CheckEnv claim digest, never its manifest index. ix prove now prints `claim ` before every proof address and records the wrapper under that digest in the shard-proof index (~/.ix/cache/shard-proofs; --no-index opts out). With --skip-proven it looks each leaf's claim up before executing anything and reuses an index entry that decodes, bundles exactly that claim and verifies natively — the whole-partition prove resumes after a refinement with one env load and the gate on. ix verify --ixe --ixes [--shard K] ADDR --record indexes a proof once it binds to its shard and verifies, which is how already-proved leaves are imported. ix shard claims lists every leaf's digest (id digest blocks consts) in one env pass for external runners. --shards K|a-b|a,b,c-d restricts ix prove (one process) and ix check to a selection; unselected leaves are carried over unchanged by --out-ixes. Checked on the 2048-way Init partition: a proved leaf is reused in 2.5 s without execution, a recorded proof turns ix shard refine into proven-kept, and ix shard claims agrees with ix verify --shard K. --- Ix/Cli/ProveCmd.lean | 59 +++++++++++++++++++++++++++++++++++++------ Ix/Cli/RefineCmd.lean | 53 ++++++++++++++++++++++++++++++++++++++ Ix/Cli/ShardCmd.lean | 3 ++- Ix/Cli/VerifyCmd.lean | 17 +++++++++++-- 4 files changed, 121 insertions(+), 11 deletions(-) diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index 872552997..e527ad14e 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -30,6 +30,7 @@ public import Ix.Aiur.Compiler public import Ix.Aiur.Protocol public import Ix.Claim public import Ix.Cli.CheckCmd +public import Ix.Cli.ShardProofIndex public import Ix.Common public import Ix.IxVM public import Ix.IxVM.Toplevel @@ -140,9 +141,23 @@ def proveOne (aiurSystem : Aiur.AiurSystem) partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) (ixonEnv : Ixon.Env) (aiurSystem : Aiur.AiurSystem) (funIdx : Aiur.Bytecode.FunIdx) (maxRamBytes : Nat) - (execOnly : Bool) (label : String) + (execOnly : Bool) (compiled : Aiur.CompiledToplevel) + (indexDir? : Option System.FilePath) (skipProven : Bool) (label : String) (blocks owned : Array Address) : IO (Except String (Array (Array Address × Nat))) := do + -- Claim-addressed resume: a leaf's identity is its claim digest, so a + -- verified proof of exactly this claim in the shard-proof index is the + -- proof this run would produce — reuse it without executing anything. + if skipProven then + if let some dir := indexDir? then + if let .ok (claim, _) := IxVM.ClaimHarness.shardCheckEnvClaimTrees ixonEnv owned then + if let some addr ← Ix.Cli.ShardProofIndex.verifiedProof aiurSystem compiled dir claim then + let digest := Address.blake3 (Ix.Claim.ser claim) + IO.println s!"[{label}] verified proof of claim {digest} in the \ + shard-proof index — reused" + IO.println s!"claim {digest}" + IO.println (toString addr) + return .ok #[(blocks, 0)] let mut blob := ByteArray.empty for a in owned do blob := blob ++ a.hash @@ -173,7 +188,8 @@ partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) for (i, part, po) in (cut.zip cutOwned).mapIdx (fun i (part, po) => (i, part, po)) do match ← proveBlocksWithinBudget envHandle ixonEnv aiurSystem funIdx - maxRamBytes execOnly s!"{label}.{i}" part po with + maxRamBytes execOnly compiled indexDir? skipProven + s!"{label}.{i}" part po with | .error e => return .error e | .ok parts => proven := proven ++ parts return .ok proven @@ -188,7 +204,14 @@ partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) + -- The claim digest is the leaf's durable identity; print it next to + -- the address so a runner can key its progress on it, and index the + -- proof under it for `--skip-proven` and `ix shard refine`. + let digest := Address.blake3 (Ix.Claim.ser claim) + IO.println s!"claim {digest}" IO.println (toString proofAddr) + if let some dir := indexDir? then + Ix.Cli.ShardProofIndex.writeAddress dir digest proofAddr return .ok #[(blocks, peakBytes)] /-- Prove shard `shardK` of the partition, splitting it as needed. @@ -196,13 +219,14 @@ partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) def runShardProveNative (envHandle : Aiur.EnvHandle) (ixonEnv : Ixon.Env) (shards ownedPerShard : Array (Array Address)) (shardK : Nat) (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) - (maxRamBytes : Nat) (execOnly : Bool) : + (maxRamBytes : Nat) (execOnly : Bool) + (indexDir? : Option System.FilePath) (skipProven : Bool) : IO (Except String (Array (Array Address × Nat))) := do match shards[shardK]?, ownedPerShard[shardK]? with | some blocks, some owned => let funIdx := compiled.getFuncIdx `verify_claim |>.get! proveBlocksWithinBudget envHandle ixonEnv aiurSystem funIdx maxRamBytes - execOnly s!"shard {shardK}" blocks owned + execOnly compiled indexDir? skipProven s!"shard {shardK}" blocks owned | _, _ => return .error s!"shard {shardK} out of range (0..{shards.size})" /-- Report the partition a prove run actually produced against the one @@ -229,6 +253,11 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do ((p.flag? "max-ram").map (·.as! Nat)).getD 0 * gibBytes let execOnly := p.hasFlag "exec-only" let outIxes := (p.flag? "out-ixes").map (·.as! String) + -- The shard-proof index: written for every proof this run persists, + -- consulted before executing a leaf under `--skip-proven`. + let skipProven := p.hasFlag "skip-proven" + let indexDir? ← if p.hasFlag "no-index" then pure none + else some <$> Ix.Cli.ShardProofIndex.indexDir -- Both `--ixes` branches end the same way: the partition the run -- actually proved, written as a refinement of the manifest it started -- from — the one the next run of this env should start from. @@ -263,7 +292,7 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do | .ok h => pure h match ← runShardProveNative envHandle ixonEnv shards (Ix.Cli.CheckCmd.ownedConstsPer ixonEnv shards) k aiurSystem - compiled maxRamBytes execOnly with + compiled maxRamBytes execOnly indexDir? skipProven with | .error e => IO.eprintln e; return 1 | .ok parts => -- A single-shard run plans exactly one shard, not the whole @@ -288,16 +317,27 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do -- once at the end rather than rewritten per split. Ownership is -- assigned in ONE env pass here; splits inherit it. let ownedPer := Ix.Cli.CheckCmd.ownedConstsPer ixonEnv shards + -- `--shards SEL` restricts the run to some leaves (one env load for + -- all of them); every other leaf is carried over unchanged. + let selected : Array Nat ← match (p.flag? "shards").map (·.as! String) with + | none => pure (Array.range shards.size) + | some s => match Ix.Cli.CheckCmd.parseShardSelection s with + | .error e => IO.eprintln s!"error: {e}"; return 1 + | .ok ids => + if let some k := ids.find? (· ≥ shards.size) then + IO.eprintln s!"--shards: shard {k} out of range ({shards.size} shards)" + return 1 + pure ids let mut runs : Array (Nat × Array (Array Address × Nat)) := #[] let mut proven : Array (Array Address × Nat) := #[] let mut failed : Array String := #[] - for k in [0 : shards.size] do + for k in selected do match ← runShardProveNative envHandle ixonEnv shards ownedPer k - aiurSystem compiled maxRamBytes execOnly with + aiurSystem compiled maxRamBytes execOnly indexDir? skipProven with | .error e => IO.eprintln e; failed := failed.push e | .ok parts => runs := runs.push (k, parts); proven := proven ++ parts if failed.isEmpty then - reportPartition proven shards.size + reportPartition proven selected.size -- Consolidation is arithmetic from the peaks this run already -- measured, never an extra execution: the measured sum only -- shrinks as shards get coarser, so the count is a safe @@ -332,8 +372,11 @@ def proveCmd : Cli.Cmd := `[Cli| "claim" : String; "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, proves the persisted claim against the `--ixe` env (single proof, skips per-const iteration)." "ixes" : String; "Path to a `.ixes` shard manifest (with --ixe). With --shard K: prove shard K. Without --shard: prove every shard in the partition." "shard" : Nat; "0-based shard index K (with --ixes and --ixe): prove that one shard's CheckEnv claim." + "shards" : String; "With --ixes and no --shard: prove only these leaves — `K`, `a-b`, or a comma list of those — in one process (one env load); every other leaf is carried over unchanged by --out-ixes." "out-ixes" : String; "Write the partition this run actually proved — splits included — as a `.ixes` manifest to this path: the manifest `ix verify --ixes` checks these proofs against, and the one the next run of this env should start from. Skipped if any shard failed." "exec-only"; "Execute each shard and measure its projected prover peak, splitting over-budget shards as usual, but never start a STARK. The cheap way to audit a partition's split behavior at scale." + "skip-proven"; "With --ixes: before executing a leaf, look its claim up in the shard-proof index (`~/.ix/cache/shard-proofs/`); a recorded proof that decodes, bundles exactly that claim and verifies natively is reused — its address printed, nothing executed — instead of proving again. How a partially proved partition resumes after a refinement." + "no-index"; "Neither read nor write the shard-proof index (every persisted proof is normally recorded there under its claim digest)." "max-ram" : Nat; "Per-shard prover-RAM budget, GiB — normally the same value the partition was sized with (`ix shard --max-ram`). Each shard is executed, its projected prover peak measured on the resulting record, and the proof attempted only if it fits; an over-budget shard is cut into the part count the peak model projects will fit, and each part re-gated, instead of being taken into the FFT phases that would exhaust the box. Omit to detect: 85% of the machine's available RAM." ARGS: diff --git a/Ix/Cli/RefineCmd.lean b/Ix/Cli/RefineCmd.lean index 1e6eded30..6af3e3934 100644 --- a/Ix/Cli/RefineCmd.lean +++ b/Ix/Cli/RefineCmd.lean @@ -113,3 +113,56 @@ def shardRefineCmd : Cli.Cmd := `[Cli| ARGS: path : String; "Path to the serialized `.ixe` environment the manifest partitions." ] + +namespace Ix.Cli.RefineCmd + +/-- `ix shard claims --ixes M.ixes [--report R.json]`: every leaf's + `CheckEnv` claim digest, one `id digest blocks consts` line per leaf, from + one env pass. The digest is a leaf's identity: what `ix prove` persists, + what `ix verify --shard K` reconstructs, and what `ix aggregate` matches + proofs on — never its manifest index. -/ +def runShardClaimsCmd (p : Cli.Parsed) : IO UInt32 := do + let some pathArg := p.positionalArg? "path" + | p.printError "error: must specify to a .ixe file"; return 1 + let ixePath := pathArg.as! String + let some manifest := (p.flag? "ixes").map (·.as! String) + | p.printError "error: --ixes is required"; return 1 + match (← Ix.Cli.CheckCmd.loadEnvAndShards manifest ixePath) with + | .error e => IO.eprintln e; return 1 + | .ok (ixonEnv, shards) => + let ownedAll := Ix.Cli.CheckCmd.ownedConstsPer ixonEnv shards + let mut rows : Array Lean.Json := #[] + let mut rc : UInt32 := 0 + for k in [0:shards.size] do + let blocks := (shards[k]?).getD #[] + let owned := (ownedAll[k]?).getD #[] + match Ix.Cli.CheckCmd.claimDigestOfOwned ixonEnv owned with + | .error e => IO.eprintln s!"shard {k}: {e}"; rc := 1 + | .ok d => + IO.println s!"{k} {d} {blocks.size} {owned.size}" + rows := rows.push (Lean.Json.mkObj [("id", Lean.toJson k), + ("claim", Lean.Json.str (toString d)), ("blocks", Lean.toJson blocks.size), + ("consts", Lean.toJson owned.size)]) + if let some out := (p.flag? "report").map (·.as! String) then + let report := Lean.Json.mkObj [("schema", Lean.Json.str "ix-refine/0"), + ("source", Lean.Json.mkObj [("path", Lean.Json.str manifest), + ("shards", Lean.toJson shards.size)]), + ("leaves", Lean.Json.arr rows)] + IO.FS.writeFile out (report.pretty ++ "\n") + IO.println s!"[claims] report → {out}" + return rc + +end Ix.Cli.RefineCmd + +open Ix.Cli.RefineCmd in +def shardClaimsCmd : Cli.Cmd := `[Cli| + "claims" VIA runShardClaimsCmd; + "Print every leaf's CheckEnv claim digest of a `.ixes` partition (`id digest blocks consts`, one line per leaf) in one env pass — the identities a claim-keyed runner tracks instead of manifest indices" + + FLAGS: + ixes : String; "The `.ixes` manifest (required)." + report : String; "Also write the rows as a provisional JSON report (`ix-refine/0`) to this path." + + ARGS: + path : String; "Path to the `.ixe` environment the manifest partitions." +] diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean index e784239b1..04b6854d8 100644 --- a/Ix/Cli/ShardCmd.lean +++ b/Ix/Cli/ShardCmd.lean @@ -216,7 +216,8 @@ def shardCmd : Cli.Cmd := `[Cli| SUBCOMMANDS: shardExtractCmd; shardGraphCmd; - shardRefineCmd + shardRefineCmd; + shardClaimsCmd ] end diff --git a/Ix/Cli/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean index ccd089bd1..4fed82ecd 100644 --- a/Ix/Cli/VerifyCmd.lean +++ b/Ix/Cli/VerifyCmd.lean @@ -23,6 +23,7 @@ public import Ix.MultiStark public import Ix.Store public import Ix.Cli.AggregateCmd public import Ix.Cli.CheckCmd +public import Ix.Cli.ShardProofIndex public section @@ -194,10 +195,17 @@ private def verifyAggregateProof (backend : AggregateBackend) - no `--shard` + proofs: composed verdict — coverage, every proof bound to a shard, and every shard covered by a valid proof. -/ def verifyShardComposition (ixePath manifestPath : String) (shardK? : Option Nat) - (proofs : List String) : IO UInt32 := do + (proofs : List String) (record : Bool := false) : IO UInt32 := do let (ixonEnv, shards) ← match (← Ix.Cli.CheckCmd.loadEnvAndShards manifestPath ixePath) with | .error e => IO.eprintln e; return 1 | .ok r => pure r + -- `--record`: a proof that binds to its shard and verifies is indexed + -- under its claim digest, for `ix prove --skip-proven` / `ix shard refine`. + let indexDir? ← if record then some <$> Ix.Cli.ShardProofIndex.indexDir else pure none + let recordProof (digest proofAddr : Address) : IO Unit := do + if let some dir := indexDir? then + Ix.Cli.ShardProofIndex.writeAddress dir digest proofAddr + IO.println s!"[verify] recorded {proofAddr} for claim {digest} in the shard-proof index" let digestOf (k : Nat) : IO (Option Address) := do match shards[k]? with | none => IO.eprintln s!"shard {k} out of range ({shards.size} shards)"; pure none @@ -224,6 +232,7 @@ def verifyShardComposition (ixePath manifestPath : String) (shardK? : Option Nat IO.eprintln s!"[verify] FAIL: proof {proofAddr} (claim {d}) is not shard {k} (claim {expected})" rc := 1 else if (← verifyOneProof aiurSystem compiled proofAddr) != 0 then rc := 1 + else recordProof d proofAddr return rc | none => if !(← Ix.Cli.CheckCmd.shardsCover ixonEnv shards) then return 1 @@ -243,7 +252,9 @@ def verifyShardComposition (ixePath manifestPath : String) (shardK? : Option Nat | none => IO.eprintln s!"[verify] FAIL: proof {proofAddr} (claim {d}) matches no shard"; rc := 1 | some k => if (← verifyOneProof aiurSystem compiled proofAddr) != 0 then rc := 1 - else covered := covered.insert k + else + covered := covered.insert k + recordProof d proofAddr let missing := (List.range shards.size).filter (fun k => !covered.contains k) if !missing.isEmpty then IO.eprintln s!"[verify] FAIL: shards lacking a valid proof: {missing}" @@ -308,6 +319,7 @@ def runVerifyCmdWith (recursionParameters : MultiStark.RecursionParameters) match (p.flag? "ixe").map (·.as! String), (p.flag? "ixes").map (·.as! String) with | some ixe, some manifest => verifyShardComposition ixe manifest ((p.flag? "shard").map (·.as! Nat)) proofs + (p.hasFlag "record") | _, _ => if proofs.isEmpty then p.printError "error: must specify ... (or --ixe + --ixes for a shard partition)" @@ -337,6 +349,7 @@ def verifyCmd : Cli.Cmd := `[Cli| "shard" : Nat; "0-based shard index K (with --ixe + --ixes). No proof: print shard K's reconstructed CheckEnv claim digest. With proof(s): bind each to shard K and verify." "aggregate"; "Interpret proofs as single-entrypoint aggregate roots. With --ixe, bind the canonical environment claim; add --ixes for the exact manifest-relative hybrid root." "structural-above" : Nat; "For --aggregate + --ixes, reproduce structural joins above N subject leaves (default 4096; must match proving)." + "record"; "With --ixe + --ixes and proof(s): after a proof binds to its shard and verifies, record it in the shard-proof index (`~/.ix/cache/shard-proofs/` → address) so `ix prove --skip-proven` and `ix shard refine` reuse it. How already-proved leaves are imported before a refinement." ARGS: ...proofs : String; "32-byte hex address(es) of persisted `Ixon.Proof` wrappers in `~/.ix/store/`. Omit when using --ixe + --ixes." From f29e7ca5254d63cda026a5cb71a492eb22869cfa Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Wed, 2 Sep 2026 07:59:29 -0400 Subject: [PATCH 33/44] Revert "Fix multi-stark PR77 merge resolution" (back to the Mathlib run's multi-stark pin) This reverts bbee8302: multi-stark back to 2892243e and lean-ffi to 93c7e529, the width-binding and multiplicity-bound protocol fields restored, and the recursive and aggregate verifier sources regenerated from the reverted DSL (with the virtual-gas meter the merge added). The later pin was experimental GPU-proving work that did not pan out, and it changed the transcript: proofs made under one pin fail to verify under the other (InvalidOpeningArgument(InvalidPowWitness), both directions). The 168 verified Mathlib shard proofs were made at 82dcc9db under 2892243e, so the branch that resumes that run has to prove and verify under the same pin. Checked with the 2048-way Init partition: this binary verifies the 82dcc9db proofs of shards 0 and 1, an 82dcc9db build verifies this binary's proof of shard 6, and claim digests are unchanged. All gates pass (cargo tests, clippy, fmt, codegen --check, ixes-manifest, ix-aggr, aggregate-activation). --- Cargo.lock | 50 +- Cargo.toml | 6 +- Ix/MultiStark/SystemDeserialize.lean | 26 +- Ix/MultiStark/Verifier.lean | 9 +- crates/aiur/src/constraints.rs | 6 +- crates/aiur/src/gadgets/bytes1.rs | 3 + crates/aiur/src/gadgets/bytes2.rs | 13 +- crates/aiur/src/lib.rs | 33 + crates/aiur/src/memory.rs | 6 +- crates/aiur/src/synthesis.rs | 86 +- crates/aiur/src/vk_codec.rs | 22 +- crates/ixvm-codegen/src/aiur_ix_aggr.rs | 214 +- crates/ixvm-codegen/src/aiur_multi_stark.rs | 3824 ++++++++++--------- 13 files changed, 2429 insertions(+), 1869 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0141466ef..9f9c6923e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -190,7 +190,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", ] @@ -333,9 +333,9 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" [[package]] name = "chacha20" -version = "0.10.2" +version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" +checksum = "d524456ba66e72eb8b115ff89e01e497f8e6d11d78b70b1aa13c0fbd97540a81" dependencies = [ "cfg-if", "cpufeatures 0.3.0", @@ -1922,7 +1922,7 @@ 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", @@ -2104,10 +2104,11 @@ dependencies = [ [[package]] name = "multi-stark" version = "0.1.0" -source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=33b4454aa63b88427b3d3cc09980fe86ddeb7e5f#33b4454aa63b88427b3d3cc09980fe86ddeb7e5f" +source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=2892243e674f9a0b3aca9004a8d00c79a23beec1#2892243e674f9a0b3aca9004a8d00c79a23beec1" dependencies = [ "bincode", "itertools 0.14.0", + "num-bigint 0.5.1", "p3-air", "p3-blake3", "p3-challenger", @@ -2536,7 +2537,7 @@ checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" [[package]] name = "p3-air" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "p3-field", "p3-matrix", @@ -2547,7 +2548,7 @@ dependencies = [ [[package]] name = "p3-blake3" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "blake3", "p3-symmetric", @@ -2557,7 +2558,7 @@ dependencies = [ [[package]] name = "p3-challenger" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "p3-field", "p3-maybe-rayon", @@ -2569,10 +2570,9 @@ dependencies = [ [[package]] name = "p3-commit" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "itertools 0.15.0", - "p3-dft", "p3-field", "p3-matrix", "p3-multilinear-util", @@ -2583,7 +2583,7 @@ dependencies = [ [[package]] name = "p3-dft" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "itertools 0.15.0", "p3-field", @@ -2597,7 +2597,7 @@ dependencies = [ [[package]] name = "p3-field" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "itertools 0.15.0", "num-bigint 0.5.1", @@ -2612,7 +2612,7 @@ dependencies = [ [[package]] name = "p3-fri" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "itertools 0.15.0", "p3-challenger", @@ -2633,7 +2633,7 @@ dependencies = [ [[package]] name = "p3-goldilocks" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "num-bigint 0.5.1", "p3-dft", @@ -2652,7 +2652,7 @@ dependencies = [ [[package]] name = "p3-keccak" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "p3-symmetric", "p3-util", @@ -2662,7 +2662,7 @@ dependencies = [ [[package]] name = "p3-matrix" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "itertools 0.15.0", "p3-field", @@ -2676,7 +2676,7 @@ dependencies = [ [[package]] name = "p3-maybe-rayon" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "rayon", ] @@ -2684,7 +2684,7 @@ dependencies = [ [[package]] name = "p3-mds" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "p3-dft", "p3-field", @@ -2696,7 +2696,7 @@ dependencies = [ [[package]] name = "p3-merkle-tree" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "itertools 0.15.0", "p3-commit", @@ -2715,7 +2715,7 @@ dependencies = [ [[package]] name = "p3-multilinear-util" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "itertools 0.15.0", "p3-field", @@ -2730,7 +2730,7 @@ dependencies = [ [[package]] name = "p3-poseidon1" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "p3-field", "p3-mds", @@ -2741,7 +2741,7 @@ dependencies = [ [[package]] name = "p3-poseidon2" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "p3-field", "p3-mds", @@ -2753,7 +2753,7 @@ dependencies = [ [[package]] name = "p3-security" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "libm", "p3-air", @@ -2765,7 +2765,7 @@ dependencies = [ [[package]] name = "p3-symmetric" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "itertools 0.15.0", "p3-field", @@ -2776,7 +2776,7 @@ dependencies = [ [[package]] name = "p3-util" version = "0.6.0" -source = "git+https://github.com/Plonky3/Plonky3?rev=3152b14a89067c83775a8076cc262ffc48a1fd7c#3152b14a89067c83775a8076cc262ffc48a1fd7c" +source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2" dependencies = [ "p3-maybe-rayon", "serde", diff --git a/Cargo.toml b/Cargo.toml index 70d17d38e..0b1ab7f29 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -42,8 +42,8 @@ ixon = { path = "crates/ixon" } ix-kernel = { path = "crates/kernel" } # lean-ffi tree (lean-ffi crate + factored-out bignat sub-crate) -bignat = { git = "https://github.com/argumentcomputer/lean-ffi.git", rev = "2a9c91eba44ea791978a086a6a19b3a922edfee5" } -lean-ffi = { git = "https://github.com/argumentcomputer/lean-ffi.git", rev = "2a9c91eba44ea791978a086a6a19b3a922edfee5" } +bignat = { git = "https://github.com/argumentcomputer/lean-ffi.git", rev = "93c7e52952ae94546be08313f4ff3922984c84d5" } +lean-ffi = { git = "https://github.com/argumentcomputer/lean-ffi.git", rev = "93c7e52952ae94546be08313f4ff3922984c84d5" } # External shared deps anyhow = "1" @@ -56,7 +56,7 @@ libc = "0.2" log = "0.4" memmap2 = "0.9" mimalloc = { version = "0.1", default-features = false } -multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "33b4454aa63b88427b3d3cc09980fe86ddeb7e5f" } +multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "2892243e674f9a0b3aca9004a8d00c79a23beec1" } nom = "7.1.3" num-bigint = "0.4.6" quickcheck = "1.0.3" 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 5e72fd32c..b6487075b 100644 --- a/Ix/MultiStark/Verifier.lean +++ b/Ix/MultiStark/Verifier.lean @@ -308,8 +308,9 @@ def verifier := ⟦ -- Replay the verifier transcript and derive the four challenges -- `(lookup, fingerprint, alpha, zeta)`. Mirrors `verify_multiple_claims`'s -- challenger sequence exactly: - -- seed = tag + protocol parameters; observe_shape (circuit count + 6 - -- metadata words per circuit) → preprocessed_commit (if any) → stage_1 → + -- seed = tag + protocol parameters; observe_shape (width-binding policy + -- word, circuit count, 7 metadata words per circuit) → preprocessed_commit + -- (if any) → stage_1 → -- log_degrees → length-prefixed claims; -- sample lookup, observe it; sample fingerprint, observe it; -- observe stage_2; observe the intermediate accumulators; sample α; @@ -602,7 +603,9 @@ def verifier := ⟦ @eg_add(@eg_mul(a0, b1), @eg_mul(a1, b0))) } - -- fingerprint(γ, args) = Σᵢ argsᵢ·γ^i as a coordinate pair: + -- fingerprint(γ, args) = Σᵢ argsᵢ·γ^i as a coordinate pair — the plain + -- Horner fold of `WidthBinding::ByConstruction`, the policy aiur declares + -- (and the transcript replay observes): -- fp(Cons(a, rest)) = (eval a, 0) + γ ⊗ fp(rest); args embed in coord 0. fn logup_fingerprint(args: List‹G›, g0: Ext, g1: Ext, nodes: List‹SysNode›, main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›, 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 { - 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/gadgets/bytes1.rs b/crates/aiur/src/gadgets/bytes1.rs index e3acd1552..4765ca953 100644 --- a/crates/aiur/src/gadgets/bytes1.rs +++ b/crates/aiur/src/gadgets/bytes1.rs @@ -139,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] diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs index e013a6a34..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![ 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 = IndexMap; +/// 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 c5ed2bcae..bfe709f6f 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, @@ -186,7 +186,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, @@ -989,4 +993,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::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, v: usize) { buf.extend_from_slice(&v.to_le_bytes()); } +fn push_u64(buf: &mut Vec, 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, id: NodeId) { @@ -185,6 +190,7 @@ fn encode_circuit(buf: &mut Vec, circuit: &Circuit) { 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, 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/ixvm-codegen/src/aiur_ix_aggr.rs b/crates/ixvm-codegen/src/aiur_ix_aggr.rs index f0786b9c9..75c02f10d 100644 --- a/crates/ixvm-codegen/src/aiur_ix_aggr.rs +++ b/crates/ixvm-codegen/src/aiur_ix_aggr.rs @@ -8660,13 +8660,23 @@ fn aiur_fn_88( let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_88] = [__v_1, __v_5, __v_6]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_13, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_88] = [__v_1, __v_14, __v_15]; if !unconstrained { record.virt += record.function_queries[88].weight(); } record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) @@ -8698,20 +8708,30 @@ fn aiur_fn_89( let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = __r_arr[1]; - let __v_8: G = G::from_u64(1); - let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - let __v_11: G = __r_arr[1]; - let __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __ret: [G; OUT_89] = [__v_13, __v_11]; + let __v_6: G = __r_arr[2]; + let __v_7: G = __r_arr[3]; + let __v_8: G = __r_arr[4]; + let __v_9: G = __r_arr[5]; + let __v_10: G = __r_arr[6]; + let __v_11: G = __r_arr[7]; + let __v_12: G = __r_arr[8]; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_14, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = G::from_u64(1); + let __v_18: G = (__v_1 - __v_17); + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_16, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_21, __v_2, __v_15, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __ret: [G; OUT_89] = [__v_22, __v_20]; if !unconstrained { record.virt += record.function_queries[89].weight(); } record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, @@ -9750,11 +9770,70 @@ fn aiur_fn_97( let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_103, __v_88]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; - let __v_106: G = G::from_u64(0); - let __v_107: G = { let __values: [G; 10] = [__v_106, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_87, __v_107]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; - let __v_108: G = __r_arr[0]; - let __ret: [G; OUT_97] = [__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]; + let __v_106: G = G::from_u64(1); + let __gb: [u8; 8] = __v_106.as_canonical_u64().to_le_bytes(); + let __v_107: G = G::from_u8(__gb[0]); + let __v_108: G = G::from_u8(__gb[1]); + let __v_109: G = G::from_u8(__gb[2]); + let __v_110: G = G::from_u8(__gb[3]); + let __v_111: G = G::from_u8(__gb[4]); + let __v_112: G = G::from_u8(__gb[5]); + let __v_113: G = G::from_u8(__gb[6]); + let __v_114: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_107; let __vj = __v_108; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_109; let __vj = __v_110; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_111; let __vj = __v_112; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_113; let __vj = __v_114; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_115: G = G::from_u64(1020); + let __v_116: G = (__v_114 - __v_115); + let __v_117: G = (__v_113 + __v_116); + let __v_118: G = (__v_112 + __v_117); + let __v_119: G = (__v_111 + __v_118); + let __v_120: G = G::from_bool((__v_119 == G::ZERO)); + let __v_121: G = (__v_109 + __v_110); + let __v_122: G = (__v_108 + __v_121); + let __v_123: G = (__v_107 + __v_122); + let __v_124: G = G::from_bool((__v_123 == G::ZERO)); + let __v_125: G = G::from_u64(256); + let __v_126: G = (__v_125 * __v_108); + let __v_127: G = G::from_u64(65536); + let __v_128: G = (__v_127 * __v_109); + let __v_129: G = G::from_u64(16777216); + let __v_130: G = (__v_129 * __v_110); + let __v_131: G = G::from_u64(4294967296); + let __v_132: G = (__v_131 * __v_111); + let __v_133: G = G::from_u64(1099511627776); + let __v_134: G = (__v_133 * __v_112); + let __v_135: G = G::from_u64(281474976710656); + let __v_136: G = (__v_135 * __v_113); + let __v_137: G = G::from_u64(72057594037927936); + let __v_138: G = (__v_137 * __v_114); + let __v_139: G = (__v_136 + __v_138); + let __v_140: G = (__v_134 + __v_139); + let __v_141: G = (__v_132 + __v_140); + let __v_142: G = (__v_130 + __v_141); + let __v_143: G = (__v_128 + __v_142); + let __v_144: G = (__v_126 + __v_143); + let __v_145: G = (__v_107 + __v_144); + if (__v_145 != __v_106) { + return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_106.as_canonical_u64(), msg: None }); + } + let __v_146: G = G::from_u64(1); + let __v_147: G = G::from_u64(1); + let __v_148: G = (__v_147 - __v_124); + let __v_149: G = (__v_120 * __v_148); + let __v_150: G = (__v_146 - __v_149); + let __v_151: G = G::from_u64(1); + if (__v_150 != __v_151) { + return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_151.as_canonical_u64(), msg: None }); + } + let __v_152: G = G::from_u64(0); + let __v_153: G = G::from_u64(0); + let __v_154: G = { let __values: [G; 10] = [__v_153, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_155: G = { let __values: [G; 10] = [__v_152, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_154]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_87, __v_155]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __v_156: G = __r_arr[0]; + let __ret: [G; OUT_97] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_156, __v_98, __v_101, __v_102, __v_104, __v_105]; if !unconstrained { record.virt += record.function_queries[97].weight(); } record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) @@ -22847,26 +22926,85 @@ fn aiur_fn_236( let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_279, __v_264]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_280: G = __r_arr[0]; let __v_281: G = __r_arr[1]; - let __v_282: G = G::from_u64(0); - let __v_283: G = { let __values: [G; 10] = [__v_282, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_275]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_263, __v_283]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; - let __v_284: G = __r_arr[0]; + let __v_282: G = G::from_u64(1); + let __gb: [u8; 8] = __v_282.as_canonical_u64().to_le_bytes(); + let __v_283: G = G::from_u8(__gb[0]); + let __v_284: G = G::from_u8(__gb[1]); + let __v_285: G = G::from_u8(__gb[2]); + let __v_286: G = G::from_u8(__gb[3]); + let __v_287: G = G::from_u8(__gb[4]); + let __v_288: G = G::from_u8(__gb[5]); + let __v_289: G = G::from_u8(__gb[6]); + let __v_290: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_283; let __vj = __v_284; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_285; let __vj = __v_286; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_287; let __vj = __v_288; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_289; let __vj = __v_290; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_291: G = G::from_u64(1020); + let __v_292: G = (__v_290 - __v_291); + let __v_293: G = (__v_289 + __v_292); + let __v_294: G = (__v_288 + __v_293); + let __v_295: G = (__v_287 + __v_294); + let __v_296: G = G::from_bool((__v_295 == G::ZERO)); + let __v_297: G = (__v_285 + __v_286); + let __v_298: G = (__v_284 + __v_297); + let __v_299: G = (__v_283 + __v_298); + let __v_300: G = G::from_bool((__v_299 == G::ZERO)); + let __v_301: G = G::from_u64(256); + let __v_302: G = (__v_301 * __v_284); + let __v_303: G = G::from_u64(65536); + let __v_304: G = (__v_303 * __v_285); + let __v_305: G = G::from_u64(16777216); + let __v_306: G = (__v_305 * __v_286); + let __v_307: G = G::from_u64(4294967296); + let __v_308: G = (__v_307 * __v_287); + let __v_309: G = G::from_u64(1099511627776); + let __v_310: G = (__v_309 * __v_288); + let __v_311: G = G::from_u64(281474976710656); + let __v_312: G = (__v_311 * __v_289); + let __v_313: G = G::from_u64(72057594037927936); + let __v_314: G = (__v_313 * __v_290); + let __v_315: G = (__v_312 + __v_314); + let __v_316: G = (__v_310 + __v_315); + let __v_317: G = (__v_308 + __v_316); + let __v_318: G = (__v_306 + __v_317); + let __v_319: G = (__v_304 + __v_318); + let __v_320: G = (__v_302 + __v_319); + let __v_321: G = (__v_283 + __v_320); + if (__v_321 != __v_282) { + return Err(ExecError::AssertEqMismatch { lhs: __v_321.as_canonical_u64(), rhs: __v_282.as_canonical_u64(), msg: None }); + } + let __v_322: G = G::from_u64(1); + let __v_323: G = G::from_u64(1); + let __v_324: G = (__v_323 - __v_300); + let __v_325: G = (__v_296 * __v_324); + let __v_326: G = (__v_322 - __v_325); + let __v_327: G = G::from_u64(1); + if (__v_326 != __v_327) { + return Err(ExecError::AssertEqMismatch { lhs: __v_326.as_canonical_u64(), rhs: __v_327.as_canonical_u64(), msg: None }); + } + let __v_328: G = G::from_u64(0); + let __v_329: G = G::from_u64(0); + let __v_330: G = { let __values: [G; 10] = [__v_329, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_275]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_331: G = { let __values: [G; 10] = [__v_328, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_330]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_263, __v_331]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __v_332: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_281.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_285: G = __loaded[0]; - let __v_286: G = __loaded[1]; - let __v_287: G = __loaded[2]; - let __v_288: G = G::from_u64(1); - let __v_289: G = G::from_u64(1); - if (__v_285 != __v_288) { - return Err(ExecError::AssertEqMismatch { lhs: __v_285.as_canonical_u64(), rhs: __v_288.as_canonical_u64(), msg: None }); + 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_286 != __v_289) { - return Err(ExecError::AssertEqMismatch { lhs: __v_286.as_canonical_u64(), rhs: __v_289.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_287 != __v_289) { - return Err(ExecError::AssertEqMismatch { lhs: __v_287.as_canonical_u64(), rhs: __v_289.as_canonical_u64(), msg: None }); + if (__v_335 != __v_337) { + return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_337.as_canonical_u64(), msg: None }); } - let __ret: [G; OUT_236] = [__v_177, __v_187, __v_197, __v_207, __v_217, __v_227, __v_237, __v_284, __v_274, __v_277, __v_278, __v_280]; + let __ret: [G; OUT_236] = [__v_177, __v_187, __v_197, __v_207, __v_217, __v_227, __v_237, __v_332, __v_274, __v_277, __v_278, __v_280]; if !unconstrained { record.virt += record.function_queries[236].weight(); } record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 9d47a6a0d..9e4899a3f 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -8660,13 +8660,23 @@ fn aiur_fn_88( let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_88] = [__v_1, __v_5, __v_6]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_13, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_88] = [__v_1, __v_14, __v_15]; if !unconstrained { record.virt += record.function_queries[88].weight(); } record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) @@ -8698,20 +8708,30 @@ fn aiur_fn_89( let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __v_7: G = __r_arr[1]; - let __v_8: G = G::from_u64(1); - let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - let __v_11: G = __r_arr[1]; - let __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __ret: [G; OUT_89] = [__v_13, __v_11]; + let __v_6: G = __r_arr[2]; + let __v_7: G = __r_arr[3]; + let __v_8: G = __r_arr[4]; + let __v_9: G = __r_arr[5]; + let __v_10: G = __r_arr[6]; + let __v_11: G = __r_arr[7]; + let __v_12: G = __r_arr[8]; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_14, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = G::from_u64(1); + let __v_18: G = (__v_1 - __v_17); + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_16, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_21, __v_2, __v_15, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __ret: [G; OUT_89] = [__v_22, __v_20]; if !unconstrained { record.virt += record.function_queries[89].weight(); } record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }, @@ -9750,11 +9770,70 @@ fn aiur_fn_97( let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_103, __v_88]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; - let __v_106: G = G::from_u64(0); - let __v_107: G = { let __values: [G; 10] = [__v_106, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_87, __v_107]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; - let __v_108: G = __r_arr[0]; - let __ret: [G; OUT_97] = [__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]; + let __v_106: G = G::from_u64(1); + let __gb: [u8; 8] = __v_106.as_canonical_u64().to_le_bytes(); + let __v_107: G = G::from_u8(__gb[0]); + let __v_108: G = G::from_u8(__gb[1]); + let __v_109: G = G::from_u8(__gb[2]); + let __v_110: G = G::from_u8(__gb[3]); + let __v_111: G = G::from_u8(__gb[4]); + let __v_112: G = G::from_u8(__gb[5]); + let __v_113: G = G::from_u8(__gb[6]); + let __v_114: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_107; let __vj = __v_108; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_109; let __vj = __v_110; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_111; let __vj = __v_112; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_113; let __vj = __v_114; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_115: G = G::from_u64(1020); + let __v_116: G = (__v_114 - __v_115); + let __v_117: G = (__v_113 + __v_116); + let __v_118: G = (__v_112 + __v_117); + let __v_119: G = (__v_111 + __v_118); + let __v_120: G = G::from_bool((__v_119 == G::ZERO)); + let __v_121: G = (__v_109 + __v_110); + let __v_122: G = (__v_108 + __v_121); + let __v_123: G = (__v_107 + __v_122); + let __v_124: G = G::from_bool((__v_123 == G::ZERO)); + let __v_125: G = G::from_u64(256); + let __v_126: G = (__v_125 * __v_108); + let __v_127: G = G::from_u64(65536); + let __v_128: G = (__v_127 * __v_109); + let __v_129: G = G::from_u64(16777216); + let __v_130: G = (__v_129 * __v_110); + let __v_131: G = G::from_u64(4294967296); + let __v_132: G = (__v_131 * __v_111); + let __v_133: G = G::from_u64(1099511627776); + let __v_134: G = (__v_133 * __v_112); + let __v_135: G = G::from_u64(281474976710656); + let __v_136: G = (__v_135 * __v_113); + let __v_137: G = G::from_u64(72057594037927936); + let __v_138: G = (__v_137 * __v_114); + let __v_139: G = (__v_136 + __v_138); + let __v_140: G = (__v_134 + __v_139); + let __v_141: G = (__v_132 + __v_140); + let __v_142: G = (__v_130 + __v_141); + let __v_143: G = (__v_128 + __v_142); + let __v_144: G = (__v_126 + __v_143); + let __v_145: G = (__v_107 + __v_144); + if (__v_145 != __v_106) { + return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_106.as_canonical_u64(), msg: None }); + } + let __v_146: G = G::from_u64(1); + let __v_147: G = G::from_u64(1); + let __v_148: G = (__v_147 - __v_124); + let __v_149: G = (__v_120 * __v_148); + let __v_150: G = (__v_146 - __v_149); + let __v_151: G = G::from_u64(1); + if (__v_150 != __v_151) { + return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_151.as_canonical_u64(), msg: None }); + } + let __v_152: G = G::from_u64(0); + let __v_153: G = G::from_u64(0); + let __v_154: G = { let __values: [G; 10] = [__v_153, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_155: G = { let __values: [G; 10] = [__v_152, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_154]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_87, __v_155]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __v_156: G = __r_arr[0]; + let __ret: [G; OUT_97] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_156, __v_98, __v_101, __v_102, __v_104, __v_105]; if !unconstrained { record.virt += record.function_queries[97].weight(); } record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); return Ok(__ret); }) @@ -23961,456 +24040,515 @@ fn aiur_fn_239( let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_384, __v_369]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_385: G = __r_arr[0]; let __v_386: G = __r_arr[1]; - let __v_387: G = G::from_u64(0); - let __v_388: G = { let __values: [G; 10] = [__v_387, __v_370, __v_371, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_380]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_368, __v_388]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; - let __v_389: G = __r_arr[0]; - let __v_390: G = G::from_u64(0); - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_389, __v_379, __v_382, __v_383, __v_385, __v_390]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; - let __v_391: G = __r_arr[0]; - let __v_392: G = G::from_u64(1); - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_389, __v_379, __v_382, __v_383, __v_385, __v_392]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; - let __v_393: G = __r_arr[0]; - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_391, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; - let __v_394: G = __r_arr[0]; - let __v_395: G = __r_arr[1]; - let __v_396: G = __r_arr[2]; - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_393, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; - let __v_397: G = __r_arr[0]; - let __v_398: G = __r_arr[1]; - let __v_399: G = __r_arr[2]; - let __v_400: G = G::from_u64(2); - let __v_401: G = G::from_u64(2); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_401]; let __info = io_buffer.get_info(__v_400, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_402: G = __io_pair.0; - let __v_403: G = __io_pair.1; - let __v_404: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_404, __v_402, __v_403]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; - let __v_405: G = __r_arr[0]; - let __v_406: G = G::from_u64(103); - let __v_407: G = G::from_u64(230); - let __v_408: G = G::from_u64(9); - let __v_409: G = G::from_u64(106); - let __v_410: G = G::from_u64(133); - let __v_411: G = G::from_u64(174); - let __v_412: G = G::from_u64(103); - let __v_413: G = G::from_u64(187); - let __v_414: G = G::from_u64(114); - let __v_415: G = G::from_u64(243); - let __v_416: G = G::from_u64(110); - let __v_417: G = G::from_u64(60); - let __v_418: G = G::from_u64(58); - let __v_419: G = G::from_u64(245); - let __v_420: G = G::from_u64(79); - let __v_421: G = G::from_u64(165); - let __v_422: G = G::from_u64(127); - let __v_423: G = G::from_u64(82); - let __v_424: G = G::from_u64(14); - let __v_425: G = G::from_u64(81); - let __v_426: G = G::from_u64(140); - let __v_427: G = G::from_u64(104); - let __v_428: G = G::from_u64(5); - let __v_429: G = G::from_u64(155); - let __v_430: G = G::from_u64(171); - let __v_431: G = G::from_u64(217); - let __v_432: G = G::from_u64(131); - let __v_433: G = G::from_u64(31); - let __v_434: G = G::from_u64(25); - let __v_435: G = G::from_u64(205); - let __v_436: G = G::from_u64(224); - let __v_437: G = G::from_u64(91); - let __v_438: G = G::from_u64(1); - let __v_439: G = G::from_u64(1); - let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_441: G = G::from_u64(0); - let __v_442: G = G::from_u64(0); - let __v_443: G = G::from_u64(0); - let __v_444: G = G::from_u64(0); - let __v_445: G = G::from_u64(0); - let __v_446: G = G::from_u64(0); - let __v_447: G = G::from_u64(0); - let __v_448: G = G::from_u64(0); - let __v_449: G = G::from_u64(0); - let __v_450: G = G::from_u64(0); - let __v_451: G = { let __values: [G; 8] = [__v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_449, __v_450]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_452: G = { let __values: [G; 32] = [__v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_453: G = G::from_u64(1); - let __v_454: G = G::from_u64(1); - let __v_455: G = { let __values: [G; 34] = [__v_453, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_405, __v_440, __v_441, __v_442, __v_451, __v_452, __v_455]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; - let __v_456: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_456]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; - let __v_457: G = __r_arr[0]; - let __v_458: G = __r_arr[1]; - let __v_459: G = __r_arr[2]; - let __v_460: G = __r_arr[3]; - let __v_461: G = __r_arr[4]; - let __v_462: G = __r_arr[5]; - let __v_463: G = __r_arr[6]; - let __v_464: G = __r_arr[7]; - let __v_465: G = __r_arr[8]; - let __v_466: G = __r_arr[9]; - let __v_467: G = __r_arr[10]; - let __v_468: G = __r_arr[11]; - let __v_469: G = __r_arr[12]; - let __v_470: G = __r_arr[13]; - let __v_471: G = __r_arr[14]; - let __v_472: G = __r_arr[15]; - let __v_473: G = __r_arr[16]; - let __v_474: G = __r_arr[17]; - let __v_475: G = __r_arr[18]; - let __v_476: G = __r_arr[19]; - let __v_477: G = __r_arr[20]; - let __v_478: G = __r_arr[21]; - let __v_479: G = __r_arr[22]; - let __v_480: G = __r_arr[23]; - let __v_481: G = __r_arr[24]; - let __v_482: G = __r_arr[25]; - let __v_483: G = __r_arr[26]; - let __v_484: G = __r_arr[27]; - let __v_485: G = __r_arr[28]; - let __v_486: G = __r_arr[29]; - let __v_487: G = __r_arr[30]; - let __v_488: G = __r_arr[31]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_405]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } }; - let __v_489: G = __r_arr[0]; - let __v_490: G = __r_arr[1]; - let __v_491: G = __r_arr[2]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_394]; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } }; - let __v_492: G = __r_arr[0]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_397]; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } }; - let __v_493: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_395, __v_396]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; - let __v_494: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_398, __v_399]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; - let __v_495: G = __r_arr[0]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_489]; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } }; - let __v_496: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_490, __v_491]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; - let __v_497: G = __r_arr[0]; - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_492, __v_493, __v_496]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_494, __v_495, __v_496, __v_497]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[225].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } }; - let __v_498: G = G::from_u64(96); - if (__v_19 != __v_498) { - return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_498.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); - } - let __v_499: G = G::from_u64(256); - let __v_500: G = (__v_499 * __v_74); - let __v_501: G = G::from_u64(65536); - let __v_502: G = (__v_501 * __v_75); - let __v_503: G = G::from_u64(16777216); - let __v_504: G = (__v_503 * __v_76); - let __v_505: G = (__v_502 + __v_504); - let __v_506: G = (__v_500 + __v_505); - let __v_507: G = (__v_73 + __v_506); - let __v_508: G = G::from_u64(256); - let __v_509: G = (__v_508 * __v_78); - let __v_510: G = G::from_u64(65536); - let __v_511: G = (__v_510 * __v_79); - let __v_512: G = G::from_u64(16777216); - let __v_513: G = (__v_512 * __v_80); - let __v_514: G = (__v_511 + __v_513); - let __v_515: G = (__v_509 + __v_514); - let __v_516: G = (__v_77 + __v_515); - let __v_517: G = G::from_u64(256); - let __v_518: G = (__v_517 * __v_82); - let __v_519: G = G::from_u64(65536); - let __v_520: G = (__v_519 * __v_83); - let __v_521: G = G::from_u64(16777216); - let __v_522: G = (__v_521 * __v_84); - let __v_523: G = (__v_520 + __v_522); - let __v_524: G = (__v_518 + __v_523); - let __v_525: G = (__v_81 + __v_524); - let __v_526: G = G::from_u64(256); - let __v_527: G = (__v_526 * __v_86); - let __v_528: G = G::from_u64(65536); - let __v_529: G = (__v_528 * __v_87); - let __v_530: G = G::from_u64(16777216); - let __v_531: G = (__v_530 * __v_88); - let __v_532: G = (__v_529 + __v_531); - let __v_533: G = (__v_527 + __v_532); - let __v_534: G = (__v_85 + __v_533); - let __v_535: G = G::from_u64(256); - let __v_536: G = (__v_535 * __v_90); - let __v_537: G = G::from_u64(65536); - let __v_538: G = (__v_537 * __v_91); - let __v_539: G = G::from_u64(16777216); - let __v_540: G = (__v_539 * __v_92); - let __v_541: G = (__v_538 + __v_540); - let __v_542: G = (__v_536 + __v_541); - let __v_543: G = (__v_89 + __v_542); - let __v_544: G = G::from_u64(256); - let __v_545: G = (__v_544 * __v_94); - let __v_546: G = G::from_u64(65536); - let __v_547: G = (__v_546 * __v_95); - let __v_548: G = G::from_u64(16777216); - let __v_549: G = (__v_548 * __v_96); - let __v_550: G = (__v_547 + __v_549); - let __v_551: G = (__v_545 + __v_550); - let __v_552: G = (__v_93 + __v_551); - let __v_553: G = G::from_u64(256); - let __v_554: G = (__v_553 * __v_98); - let __v_555: G = G::from_u64(65536); - let __v_556: G = (__v_555 * __v_99); - let __v_557: G = G::from_u64(16777216); - let __v_558: G = (__v_557 * __v_100); - let __v_559: G = (__v_556 + __v_558); - let __v_560: G = (__v_554 + __v_559); - let __v_561: G = (__v_97 + __v_560); - let __v_562: G = G::from_u64(256); - let __v_563: G = (__v_562 * __v_102); - let __v_564: G = G::from_u64(65536); - let __v_565: G = (__v_564 * __v_103); - let __v_566: G = G::from_u64(16777216); - let __v_567: G = (__v_566 * __v_104); - let __v_568: G = (__v_565 + __v_567); - let __v_569: G = (__v_563 + __v_568); - let __v_570: G = (__v_101 + __v_569); - if (__v_507 != __v_0) { - return Err(ExecError::AssertEqMismatch { lhs: __v_507.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_516 != __v_1) { - return Err(ExecError::AssertEqMismatch { lhs: __v_516.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_525 != __v_2) { - return Err(ExecError::AssertEqMismatch { lhs: __v_525.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_534 != __v_3) { - return Err(ExecError::AssertEqMismatch { lhs: __v_534.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_543 != __v_4) { - return Err(ExecError::AssertEqMismatch { lhs: __v_543.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_552 != __v_5) { - return Err(ExecError::AssertEqMismatch { lhs: __v_552.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_561 != __v_6) { - return Err(ExecError::AssertEqMismatch { lhs: __v_561.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); - } - if (__v_570 != __v_7) { - return Err(ExecError::AssertEqMismatch { lhs: __v_570.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + let __v_387: G = G::from_u64(1); + let __gb: [u8; 8] = __v_387.as_canonical_u64().to_le_bytes(); + let __v_388: G = G::from_u8(__gb[0]); + let __v_389: G = G::from_u8(__gb[1]); + let __v_390: G = G::from_u8(__gb[2]); + let __v_391: G = G::from_u8(__gb[3]); + let __v_392: G = G::from_u8(__gb[4]); + let __v_393: G = G::from_u8(__gb[5]); + let __v_394: G = G::from_u8(__gb[6]); + let __v_395: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_388; let __vj = __v_389; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_390; let __vj = __v_391; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_392; let __vj = __v_393; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_394; let __vj = __v_395; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_396: G = G::from_u64(1020); + let __v_397: G = (__v_395 - __v_396); + let __v_398: G = (__v_394 + __v_397); + let __v_399: G = (__v_393 + __v_398); + let __v_400: G = (__v_392 + __v_399); + let __v_401: G = G::from_bool((__v_400 == G::ZERO)); + let __v_402: G = (__v_390 + __v_391); + let __v_403: G = (__v_389 + __v_402); + let __v_404: G = (__v_388 + __v_403); + let __v_405: G = G::from_bool((__v_404 == G::ZERO)); + let __v_406: G = G::from_u64(256); + let __v_407: G = (__v_406 * __v_389); + let __v_408: G = G::from_u64(65536); + let __v_409: G = (__v_408 * __v_390); + let __v_410: G = G::from_u64(16777216); + let __v_411: G = (__v_410 * __v_391); + let __v_412: G = G::from_u64(4294967296); + let __v_413: G = (__v_412 * __v_392); + let __v_414: G = G::from_u64(1099511627776); + let __v_415: G = (__v_414 * __v_393); + let __v_416: G = G::from_u64(281474976710656); + let __v_417: G = (__v_416 * __v_394); + let __v_418: G = G::from_u64(72057594037927936); + let __v_419: G = (__v_418 * __v_395); + let __v_420: G = (__v_417 + __v_419); + let __v_421: G = (__v_415 + __v_420); + let __v_422: G = (__v_413 + __v_421); + let __v_423: G = (__v_411 + __v_422); + let __v_424: G = (__v_409 + __v_423); + let __v_425: G = (__v_407 + __v_424); + let __v_426: G = (__v_388 + __v_425); + if (__v_426 != __v_387) { + return Err(ExecError::AssertEqMismatch { lhs: __v_426.as_canonical_u64(), rhs: __v_387.as_canonical_u64(), msg: None }); + } + let __v_427: G = G::from_u64(1); + let __v_428: G = G::from_u64(1); + let __v_429: G = (__v_428 - __v_405); + let __v_430: G = (__v_401 * __v_429); + let __v_431: G = (__v_427 - __v_430); + let __v_432: G = G::from_u64(1); + if (__v_431 != __v_432) { + return Err(ExecError::AssertEqMismatch { lhs: __v_431.as_canonical_u64(), rhs: __v_432.as_canonical_u64(), msg: None }); + } + let __v_433: G = G::from_u64(0); + let __v_434: G = G::from_u64(0); + let __v_435: G = { let __values: [G; 10] = [__v_434, __v_370, __v_371, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_380]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_436: G = { let __values: [G; 10] = [__v_433, __v_388, __v_389, __v_390, __v_391, __v_392, __v_393, __v_394, __v_395, __v_435]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_368, __v_436]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __v_437: G = __r_arr[0]; + let __v_438: G = G::from_u64(0); + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_437, __v_379, __v_382, __v_383, __v_385, __v_438]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __v_439: G = __r_arr[0]; + let __v_440: G = G::from_u64(1); + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_437, __v_379, __v_382, __v_383, __v_385, __v_440]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __v_441: G = __r_arr[0]; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_439, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __v_442: G = __r_arr[0]; + let __v_443: G = __r_arr[1]; + let __v_444: G = __r_arr[2]; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_441, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __v_445: G = __r_arr[0]; + let __v_446: G = __r_arr[1]; + let __v_447: G = __r_arr[2]; + let __v_448: G = G::from_u64(2); + let __v_449: G = G::from_u64(2); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_449]; let __info = io_buffer.get_info(__v_448, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_450: G = __io_pair.0; + let __v_451: G = __io_pair.1; + let __v_452: G = G::from_u64(2); + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_452, __v_450, __v_451]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __v_453: G = __r_arr[0]; + let __v_454: G = G::from_u64(103); + let __v_455: G = G::from_u64(230); + let __v_456: G = G::from_u64(9); + let __v_457: G = G::from_u64(106); + let __v_458: G = G::from_u64(133); + let __v_459: G = G::from_u64(174); + let __v_460: G = G::from_u64(103); + let __v_461: G = G::from_u64(187); + let __v_462: G = G::from_u64(114); + let __v_463: G = G::from_u64(243); + let __v_464: G = G::from_u64(110); + let __v_465: G = G::from_u64(60); + let __v_466: G = G::from_u64(58); + let __v_467: G = G::from_u64(245); + let __v_468: G = G::from_u64(79); + let __v_469: G = G::from_u64(165); + let __v_470: G = G::from_u64(127); + let __v_471: G = G::from_u64(82); + let __v_472: G = G::from_u64(14); + let __v_473: G = G::from_u64(81); + let __v_474: G = G::from_u64(140); + let __v_475: G = G::from_u64(104); + let __v_476: G = G::from_u64(5); + let __v_477: G = G::from_u64(155); + let __v_478: G = G::from_u64(171); + let __v_479: G = G::from_u64(217); + let __v_480: G = G::from_u64(131); + let __v_481: G = G::from_u64(31); + let __v_482: G = G::from_u64(25); + let __v_483: G = G::from_u64(205); + let __v_484: G = G::from_u64(224); + let __v_485: G = G::from_u64(91); + let __v_486: G = G::from_u64(1); + let __v_487: G = G::from_u64(1); + let __v_488: G = { let __values: [G; 3] = [__v_486, __v_487, __v_487]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_489: G = G::from_u64(0); + let __v_490: G = G::from_u64(0); + let __v_491: G = G::from_u64(0); + let __v_492: G = G::from_u64(0); + let __v_493: G = G::from_u64(0); + let __v_494: G = G::from_u64(0); + let __v_495: G = G::from_u64(0); + let __v_496: G = G::from_u64(0); + let __v_497: G = G::from_u64(0); + let __v_498: G = G::from_u64(0); + let __v_499: G = { let __values: [G; 8] = [__v_491, __v_492, __v_493, __v_494, __v_495, __v_496, __v_497, __v_498]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_500: G = { let __values: [G; 32] = [__v_454, __v_455, __v_456, __v_457, __v_458, __v_459, __v_460, __v_461, __v_462, __v_463, __v_464, __v_465, __v_466, __v_467, __v_468, __v_469, __v_470, __v_471, __v_472, __v_473, __v_474, __v_475, __v_476, __v_477, __v_478, __v_479, __v_480, __v_481, __v_482, __v_483, __v_484, __v_485]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_501: G = G::from_u64(1); + let __v_502: G = G::from_u64(1); + let __v_503: G = { let __values: [G; 34] = [__v_501, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_453, __v_488, __v_489, __v_490, __v_499, __v_500, __v_503]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_504: G = __r_arr[0]; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_504]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __v_505: G = __r_arr[0]; + let __v_506: G = __r_arr[1]; + let __v_507: G = __r_arr[2]; + let __v_508: G = __r_arr[3]; + let __v_509: G = __r_arr[4]; + let __v_510: G = __r_arr[5]; + let __v_511: G = __r_arr[6]; + let __v_512: G = __r_arr[7]; + let __v_513: G = __r_arr[8]; + let __v_514: G = __r_arr[9]; + let __v_515: G = __r_arr[10]; + let __v_516: G = __r_arr[11]; + let __v_517: G = __r_arr[12]; + let __v_518: G = __r_arr[13]; + let __v_519: G = __r_arr[14]; + let __v_520: G = __r_arr[15]; + let __v_521: G = __r_arr[16]; + let __v_522: G = __r_arr[17]; + let __v_523: G = __r_arr[18]; + let __v_524: G = __r_arr[19]; + let __v_525: G = __r_arr[20]; + let __v_526: G = __r_arr[21]; + let __v_527: G = __r_arr[22]; + let __v_528: G = __r_arr[23]; + let __v_529: G = __r_arr[24]; + let __v_530: G = __r_arr[25]; + let __v_531: G = __r_arr[26]; + let __v_532: G = __r_arr[27]; + let __v_533: G = __r_arr[28]; + let __v_534: G = __r_arr[29]; + let __v_535: G = __r_arr[30]; + let __v_536: G = __r_arr[31]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_453]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __v_537: G = __r_arr[0]; + let __v_538: G = __r_arr[1]; + let __v_539: G = __r_arr[2]; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_442]; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __v_540: G = __r_arr[0]; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_445]; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __v_541: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_443, __v_444]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __v_542: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_446, __v_447]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __v_543: G = __r_arr[0]; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_537]; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __v_544: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_538, __v_539]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __v_545: G = __r_arr[0]; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_540, __v_541, __v_544]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_542, __v_543, __v_544, __v_545]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[225].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __v_546: G = G::from_u64(96); + if (__v_19 != __v_546) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_546.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); + } + let __v_547: G = G::from_u64(256); + let __v_548: G = (__v_547 * __v_74); + let __v_549: G = G::from_u64(65536); + let __v_550: G = (__v_549 * __v_75); + let __v_551: G = G::from_u64(16777216); + let __v_552: G = (__v_551 * __v_76); + let __v_553: G = (__v_550 + __v_552); + let __v_554: G = (__v_548 + __v_553); + let __v_555: G = (__v_73 + __v_554); + let __v_556: G = G::from_u64(256); + let __v_557: G = (__v_556 * __v_78); + let __v_558: G = G::from_u64(65536); + let __v_559: G = (__v_558 * __v_79); + let __v_560: G = G::from_u64(16777216); + let __v_561: G = (__v_560 * __v_80); + let __v_562: G = (__v_559 + __v_561); + let __v_563: G = (__v_557 + __v_562); + let __v_564: G = (__v_77 + __v_563); + let __v_565: G = G::from_u64(256); + let __v_566: G = (__v_565 * __v_82); + let __v_567: G = G::from_u64(65536); + let __v_568: G = (__v_567 * __v_83); + let __v_569: G = G::from_u64(16777216); + let __v_570: G = (__v_569 * __v_84); + let __v_571: G = (__v_568 + __v_570); + let __v_572: G = (__v_566 + __v_571); + let __v_573: G = (__v_81 + __v_572); + let __v_574: G = G::from_u64(256); + let __v_575: G = (__v_574 * __v_86); + let __v_576: G = G::from_u64(65536); + let __v_577: G = (__v_576 * __v_87); + let __v_578: G = G::from_u64(16777216); + let __v_579: G = (__v_578 * __v_88); + let __v_580: G = (__v_577 + __v_579); + let __v_581: G = (__v_575 + __v_580); + let __v_582: G = (__v_85 + __v_581); + let __v_583: G = G::from_u64(256); + let __v_584: G = (__v_583 * __v_90); + let __v_585: G = G::from_u64(65536); + let __v_586: G = (__v_585 * __v_91); + let __v_587: G = G::from_u64(16777216); + let __v_588: G = (__v_587 * __v_92); + let __v_589: G = (__v_586 + __v_588); + let __v_590: G = (__v_584 + __v_589); + let __v_591: G = (__v_89 + __v_590); + let __v_592: G = G::from_u64(256); + let __v_593: G = (__v_592 * __v_94); + let __v_594: G = G::from_u64(65536); + let __v_595: G = (__v_594 * __v_95); + let __v_596: G = G::from_u64(16777216); + let __v_597: G = (__v_596 * __v_96); + let __v_598: G = (__v_595 + __v_597); + let __v_599: G = (__v_593 + __v_598); + let __v_600: G = (__v_93 + __v_599); + let __v_601: G = G::from_u64(256); + let __v_602: G = (__v_601 * __v_98); + let __v_603: G = G::from_u64(65536); + let __v_604: G = (__v_603 * __v_99); + let __v_605: G = G::from_u64(16777216); + let __v_606: G = (__v_605 * __v_100); + let __v_607: G = (__v_604 + __v_606); + let __v_608: G = (__v_602 + __v_607); + let __v_609: G = (__v_97 + __v_608); + let __v_610: G = G::from_u64(256); + let __v_611: G = (__v_610 * __v_102); + let __v_612: G = G::from_u64(65536); + let __v_613: G = (__v_612 * __v_103); + let __v_614: G = G::from_u64(16777216); + let __v_615: G = (__v_614 * __v_104); + let __v_616: G = (__v_613 + __v_615); + let __v_617: G = (__v_611 + __v_616); + let __v_618: G = (__v_101 + __v_617); + if (__v_555 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_555.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) }); + } + 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_571: G = __loaded[0]; - let __v_572: G = __loaded[1]; - let __v_573: G = __loaded[2]; - let __v_574: G = G::from_u64(1); - let __v_575: G = G::from_u64(1); - if (__v_571 != __v_574) { - return Err(ExecError::AssertEqMismatch { lhs: __v_571.as_canonical_u64(), rhs: __v_574.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); - } - if (__v_572 != __v_575) { - return Err(ExecError::AssertEqMismatch { lhs: __v_572.as_canonical_u64(), rhs: __v_575.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); - } - if (__v_573 != __v_575) { - return Err(ExecError::AssertEqMismatch { lhs: __v_573.as_canonical_u64(), rhs: __v_575.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); - } - let __v_576: G = G::from_u64(256); - let __v_577: G = (__v_576 * __v_251); - let __v_578: G = G::from_u64(65536); - let __v_579: G = (__v_578 * __v_252); - let __v_580: G = G::from_u64(16777216); - let __v_581: G = (__v_580 * __v_253); - let __v_582: G = (__v_579 + __v_581); - let __v_583: G = (__v_577 + __v_582); - let __v_584: G = (__v_250 + __v_583); - let __v_585: G = G::from_u64(256); - let __v_586: G = (__v_585 * __v_255); - let __v_587: G = G::from_u64(65536); - let __v_588: G = (__v_587 * __v_256); - let __v_589: G = G::from_u64(16777216); - let __v_590: G = (__v_589 * __v_257); - let __v_591: G = (__v_588 + __v_590); - let __v_592: G = (__v_586 + __v_591); - let __v_593: G = (__v_254 + __v_592); - let __v_594: G = G::from_u64(256); - let __v_595: G = (__v_594 * __v_259); - let __v_596: G = G::from_u64(65536); - let __v_597: G = (__v_596 * __v_260); - let __v_598: G = G::from_u64(16777216); - let __v_599: G = (__v_598 * __v_261); - let __v_600: G = (__v_597 + __v_599); - let __v_601: G = (__v_595 + __v_600); - let __v_602: G = (__v_258 + __v_601); - let __v_603: G = G::from_u64(256); - let __v_604: G = (__v_603 * __v_263); - let __v_605: G = G::from_u64(65536); - let __v_606: G = (__v_605 * __v_264); - let __v_607: G = G::from_u64(16777216); - let __v_608: G = (__v_607 * __v_265); - let __v_609: G = (__v_606 + __v_608); - let __v_610: G = (__v_604 + __v_609); - let __v_611: G = (__v_262 + __v_610); - let __v_612: G = G::from_u64(256); - let __v_613: G = (__v_612 * __v_267); - let __v_614: G = G::from_u64(65536); - let __v_615: G = (__v_614 * __v_268); - let __v_616: G = G::from_u64(16777216); - let __v_617: G = (__v_616 * __v_269); - let __v_618: G = (__v_615 + __v_617); - let __v_619: G = (__v_613 + __v_618); - let __v_620: G = (__v_266 + __v_619); - let __v_621: G = G::from_u64(256); - let __v_622: G = (__v_621 * __v_271); - let __v_623: G = G::from_u64(65536); - let __v_624: G = (__v_623 * __v_272); - let __v_625: G = G::from_u64(16777216); - let __v_626: G = (__v_625 * __v_273); - let __v_627: G = (__v_624 + __v_626); - let __v_628: G = (__v_622 + __v_627); - let __v_629: G = (__v_270 + __v_628); - let __v_630: G = G::from_u64(256); - let __v_631: G = (__v_630 * __v_275); - let __v_632: G = G::from_u64(65536); - let __v_633: G = (__v_632 * __v_276); - let __v_634: G = G::from_u64(16777216); - let __v_635: G = (__v_634 * __v_277); - let __v_636: G = (__v_633 + __v_635); - let __v_637: G = (__v_631 + __v_636); - let __v_638: G = (__v_274 + __v_637); - let __v_639: G = G::from_u64(256); - let __v_640: G = (__v_639 * __v_279); - let __v_641: G = G::from_u64(65536); - let __v_642: G = (__v_641 * __v_280); - let __v_643: G = G::from_u64(16777216); - let __v_644: G = (__v_643 * __v_281); - let __v_645: G = (__v_642 + __v_644); - let __v_646: G = (__v_640 + __v_645); - let __v_647: G = (__v_278 + __v_646); - if (__v_584 != __v_181) { - return Err(ExecError::AssertEqMismatch { lhs: __v_584.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_593 != __v_182) { - return Err(ExecError::AssertEqMismatch { lhs: __v_593.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_602 != __v_183) { - return Err(ExecError::AssertEqMismatch { lhs: __v_602.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_611 != __v_184) { - return Err(ExecError::AssertEqMismatch { lhs: __v_611.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_620 != __v_185) { - return Err(ExecError::AssertEqMismatch { lhs: __v_620.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_629 != __v_186) { - return Err(ExecError::AssertEqMismatch { lhs: __v_629.as_canonical_u64(), rhs: __v_186.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_638 != __v_187) { - return Err(ExecError::AssertEqMismatch { lhs: __v_638.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); - } - if (__v_647 != __v_188) { - return Err(ExecError::AssertEqMismatch { lhs: __v_647.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + let __v_619: G = __loaded[0]; + let __v_620: G = __loaded[1]; + let __v_621: G = __loaded[2]; + let __v_622: G = G::from_u64(1); + let __v_623: G = G::from_u64(1); + if (__v_619 != __v_622) { + return Err(ExecError::AssertEqMismatch { lhs: __v_619.as_canonical_u64(), rhs: __v_622.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); + } + if (__v_620 != __v_623) { + return Err(ExecError::AssertEqMismatch { lhs: __v_620.as_canonical_u64(), rhs: __v_623.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); + } + if (__v_621 != __v_623) { + return Err(ExecError::AssertEqMismatch { lhs: __v_621.as_canonical_u64(), rhs: __v_623.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) }); + } + let __v_624: G = G::from_u64(256); + let __v_625: G = (__v_624 * __v_251); + let __v_626: G = G::from_u64(65536); + let __v_627: G = (__v_626 * __v_252); + let __v_628: G = G::from_u64(16777216); + let __v_629: G = (__v_628 * __v_253); + let __v_630: G = (__v_627 + __v_629); + let __v_631: G = (__v_625 + __v_630); + let __v_632: G = (__v_250 + __v_631); + let __v_633: G = G::from_u64(256); + let __v_634: G = (__v_633 * __v_255); + let __v_635: G = G::from_u64(65536); + let __v_636: G = (__v_635 * __v_256); + let __v_637: G = G::from_u64(16777216); + let __v_638: G = (__v_637 * __v_257); + let __v_639: G = (__v_636 + __v_638); + let __v_640: G = (__v_634 + __v_639); + let __v_641: G = (__v_254 + __v_640); + let __v_642: G = G::from_u64(256); + let __v_643: G = (__v_642 * __v_259); + let __v_644: G = G::from_u64(65536); + let __v_645: G = (__v_644 * __v_260); + let __v_646: G = G::from_u64(16777216); + let __v_647: G = (__v_646 * __v_261); + let __v_648: G = (__v_645 + __v_647); + let __v_649: G = (__v_643 + __v_648); + let __v_650: G = (__v_258 + __v_649); + let __v_651: G = G::from_u64(256); + let __v_652: G = (__v_651 * __v_263); + let __v_653: G = G::from_u64(65536); + let __v_654: G = (__v_653 * __v_264); + let __v_655: G = G::from_u64(16777216); + let __v_656: G = (__v_655 * __v_265); + let __v_657: G = (__v_654 + __v_656); + let __v_658: G = (__v_652 + __v_657); + let __v_659: G = (__v_262 + __v_658); + let __v_660: G = G::from_u64(256); + let __v_661: G = (__v_660 * __v_267); + let __v_662: G = G::from_u64(65536); + let __v_663: G = (__v_662 * __v_268); + let __v_664: G = G::from_u64(16777216); + let __v_665: G = (__v_664 * __v_269); + let __v_666: G = (__v_663 + __v_665); + let __v_667: G = (__v_661 + __v_666); + let __v_668: G = (__v_266 + __v_667); + let __v_669: G = G::from_u64(256); + let __v_670: G = (__v_669 * __v_271); + let __v_671: G = G::from_u64(65536); + let __v_672: G = (__v_671 * __v_272); + let __v_673: G = G::from_u64(16777216); + let __v_674: G = (__v_673 * __v_273); + let __v_675: G = (__v_672 + __v_674); + let __v_676: G = (__v_670 + __v_675); + let __v_677: G = (__v_270 + __v_676); + let __v_678: G = G::from_u64(256); + let __v_679: G = (__v_678 * __v_275); + let __v_680: G = G::from_u64(65536); + let __v_681: G = (__v_680 * __v_276); + let __v_682: G = G::from_u64(16777216); + let __v_683: G = (__v_682 * __v_277); + let __v_684: G = (__v_681 + __v_683); + let __v_685: G = (__v_679 + __v_684); + let __v_686: G = (__v_274 + __v_685); + let __v_687: G = G::from_u64(256); + let __v_688: G = (__v_687 * __v_279); + let __v_689: G = G::from_u64(65536); + let __v_690: G = (__v_689 * __v_280); + let __v_691: G = G::from_u64(16777216); + let __v_692: G = (__v_691 * __v_281); + let __v_693: G = (__v_690 + __v_692); + let __v_694: G = (__v_688 + __v_693); + let __v_695: G = (__v_278 + __v_694); + if (__v_632 != __v_181) { + return Err(ExecError::AssertEqMismatch { lhs: __v_632.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_641 != __v_182) { + return Err(ExecError::AssertEqMismatch { lhs: __v_641.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_650 != __v_183) { + return Err(ExecError::AssertEqMismatch { lhs: __v_650.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_659 != __v_184) { + return Err(ExecError::AssertEqMismatch { lhs: __v_659.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_668 != __v_185) { + return Err(ExecError::AssertEqMismatch { lhs: __v_668.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_677 != __v_186) { + return Err(ExecError::AssertEqMismatch { lhs: __v_677.as_canonical_u64(), rhs: __v_186.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_686 != __v_187) { + return Err(ExecError::AssertEqMismatch { lhs: __v_686.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); + } + if (__v_695 != __v_188) { + return Err(ExecError::AssertEqMismatch { lhs: __v_695.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) }); } let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_386.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_648: G = __loaded[0]; - let __v_649: G = __loaded[1]; - let __v_650: G = __loaded[2]; - let __v_651: G = G::from_u64(1); - let __v_652: G = G::from_u64(1); - if (__v_648 != __v_651) { - return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_651.as_canonical_u64(), msg: None }); - } - if (__v_649 != __v_652) { - return Err(ExecError::AssertEqMismatch { lhs: __v_649.as_canonical_u64(), rhs: __v_652.as_canonical_u64(), msg: None }); - } - if (__v_650 != __v_652) { - return Err(ExecError::AssertEqMismatch { lhs: __v_650.as_canonical_u64(), rhs: __v_652.as_canonical_u64(), msg: None }); - } - let __v_653: G = G::from_u64(256); - let __v_654: G = (__v_653 * __v_458); - let __v_655: G = G::from_u64(65536); - let __v_656: G = (__v_655 * __v_459); - let __v_657: G = G::from_u64(16777216); - let __v_658: G = (__v_657 * __v_460); - let __v_659: G = (__v_656 + __v_658); - let __v_660: G = (__v_654 + __v_659); - let __v_661: G = (__v_457 + __v_660); - let __v_662: G = G::from_u64(256); - let __v_663: G = (__v_662 * __v_462); - let __v_664: G = G::from_u64(65536); - let __v_665: G = (__v_664 * __v_463); - let __v_666: G = G::from_u64(16777216); - let __v_667: G = (__v_666 * __v_464); - let __v_668: G = (__v_665 + __v_667); - let __v_669: G = (__v_663 + __v_668); - let __v_670: G = (__v_461 + __v_669); - let __v_671: G = G::from_u64(256); - let __v_672: G = (__v_671 * __v_466); - let __v_673: G = G::from_u64(65536); - let __v_674: G = (__v_673 * __v_467); - let __v_675: G = G::from_u64(16777216); - let __v_676: G = (__v_675 * __v_468); - let __v_677: G = (__v_674 + __v_676); - let __v_678: G = (__v_672 + __v_677); - let __v_679: G = (__v_465 + __v_678); - let __v_680: G = G::from_u64(256); - let __v_681: G = (__v_680 * __v_470); - let __v_682: G = G::from_u64(65536); - let __v_683: G = (__v_682 * __v_471); - let __v_684: G = G::from_u64(16777216); - let __v_685: G = (__v_684 * __v_472); - let __v_686: G = (__v_683 + __v_685); - let __v_687: G = (__v_681 + __v_686); - let __v_688: G = (__v_469 + __v_687); - let __v_689: G = G::from_u64(256); - let __v_690: G = (__v_689 * __v_474); - let __v_691: G = G::from_u64(65536); - let __v_692: G = (__v_691 * __v_475); - let __v_693: G = G::from_u64(16777216); - let __v_694: G = (__v_693 * __v_476); - let __v_695: G = (__v_692 + __v_694); - let __v_696: G = (__v_690 + __v_695); - let __v_697: G = (__v_473 + __v_696); - let __v_698: G = G::from_u64(256); - let __v_699: G = (__v_698 * __v_478); - let __v_700: G = G::from_u64(65536); - let __v_701: G = (__v_700 * __v_479); - let __v_702: G = G::from_u64(16777216); - let __v_703: G = (__v_702 * __v_480); - let __v_704: G = (__v_701 + __v_703); - let __v_705: G = (__v_699 + __v_704); - let __v_706: G = (__v_477 + __v_705); - let __v_707: G = G::from_u64(256); - let __v_708: G = (__v_707 * __v_482); - let __v_709: G = G::from_u64(65536); - let __v_710: G = (__v_709 * __v_483); - let __v_711: G = G::from_u64(16777216); - let __v_712: G = (__v_711 * __v_484); - let __v_713: G = (__v_710 + __v_712); - let __v_714: G = (__v_708 + __v_713); - let __v_715: G = (__v_481 + __v_714); - let __v_716: G = G::from_u64(256); - let __v_717: G = (__v_716 * __v_486); - let __v_718: G = G::from_u64(65536); - let __v_719: G = (__v_718 * __v_487); - let __v_720: G = G::from_u64(16777216); - let __v_721: G = (__v_720 * __v_488); - let __v_722: G = (__v_719 + __v_721); - let __v_723: G = (__v_717 + __v_722); - let __v_724: G = (__v_485 + __v_723); - if (__v_661 != __v_8) { - return Err(ExecError::AssertEqMismatch { lhs: __v_661.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_670 != __v_9) { - return Err(ExecError::AssertEqMismatch { lhs: __v_670.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_679 != __v_10) { - return Err(ExecError::AssertEqMismatch { lhs: __v_679.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_688 != __v_11) { - return Err(ExecError::AssertEqMismatch { lhs: __v_688.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_697 != __v_12) { - return Err(ExecError::AssertEqMismatch { lhs: __v_697.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_706 != __v_13) { - return Err(ExecError::AssertEqMismatch { lhs: __v_706.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_715 != __v_14) { - return Err(ExecError::AssertEqMismatch { lhs: __v_715.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); - } - if (__v_724 != __v_15) { - return Err(ExecError::AssertEqMismatch { lhs: __v_724.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + let __v_696: G = __loaded[0]; + let __v_697: G = __loaded[1]; + let __v_698: G = __loaded[2]; + let __v_699: G = G::from_u64(1); + let __v_700: G = G::from_u64(1); + if (__v_696 != __v_699) { + return Err(ExecError::AssertEqMismatch { lhs: __v_696.as_canonical_u64(), rhs: __v_699.as_canonical_u64(), msg: None }); + } + if (__v_697 != __v_700) { + return Err(ExecError::AssertEqMismatch { lhs: __v_697.as_canonical_u64(), rhs: __v_700.as_canonical_u64(), msg: None }); + } + if (__v_698 != __v_700) { + return Err(ExecError::AssertEqMismatch { lhs: __v_698.as_canonical_u64(), rhs: __v_700.as_canonical_u64(), msg: None }); + } + let __v_701: G = G::from_u64(256); + let __v_702: G = (__v_701 * __v_506); + let __v_703: G = G::from_u64(65536); + let __v_704: G = (__v_703 * __v_507); + let __v_705: G = G::from_u64(16777216); + let __v_706: G = (__v_705 * __v_508); + let __v_707: G = (__v_704 + __v_706); + let __v_708: G = (__v_702 + __v_707); + let __v_709: G = (__v_505 + __v_708); + let __v_710: G = G::from_u64(256); + let __v_711: G = (__v_710 * __v_510); + let __v_712: G = G::from_u64(65536); + let __v_713: G = (__v_712 * __v_511); + let __v_714: G = G::from_u64(16777216); + let __v_715: G = (__v_714 * __v_512); + let __v_716: G = (__v_713 + __v_715); + let __v_717: G = (__v_711 + __v_716); + let __v_718: G = (__v_509 + __v_717); + let __v_719: G = G::from_u64(256); + let __v_720: G = (__v_719 * __v_514); + let __v_721: G = G::from_u64(65536); + let __v_722: G = (__v_721 * __v_515); + let __v_723: G = G::from_u64(16777216); + let __v_724: G = (__v_723 * __v_516); + let __v_725: G = (__v_722 + __v_724); + let __v_726: G = (__v_720 + __v_725); + let __v_727: G = (__v_513 + __v_726); + let __v_728: G = G::from_u64(256); + let __v_729: G = (__v_728 * __v_518); + let __v_730: G = G::from_u64(65536); + let __v_731: G = (__v_730 * __v_519); + let __v_732: G = G::from_u64(16777216); + let __v_733: G = (__v_732 * __v_520); + let __v_734: G = (__v_731 + __v_733); + let __v_735: G = (__v_729 + __v_734); + let __v_736: G = (__v_517 + __v_735); + let __v_737: G = G::from_u64(256); + let __v_738: G = (__v_737 * __v_522); + let __v_739: G = G::from_u64(65536); + let __v_740: G = (__v_739 * __v_523); + let __v_741: G = G::from_u64(16777216); + let __v_742: G = (__v_741 * __v_524); + let __v_743: G = (__v_740 + __v_742); + let __v_744: G = (__v_738 + __v_743); + let __v_745: G = (__v_521 + __v_744); + let __v_746: G = G::from_u64(256); + let __v_747: G = (__v_746 * __v_526); + let __v_748: G = G::from_u64(65536); + let __v_749: G = (__v_748 * __v_527); + let __v_750: G = G::from_u64(16777216); + let __v_751: G = (__v_750 * __v_528); + let __v_752: G = (__v_749 + __v_751); + let __v_753: G = (__v_747 + __v_752); + let __v_754: G = (__v_525 + __v_753); + let __v_755: G = G::from_u64(256); + let __v_756: G = (__v_755 * __v_530); + let __v_757: G = G::from_u64(65536); + let __v_758: G = (__v_757 * __v_531); + let __v_759: G = G::from_u64(16777216); + let __v_760: G = (__v_759 * __v_532); + let __v_761: G = (__v_758 + __v_760); + let __v_762: G = (__v_756 + __v_761); + let __v_763: G = (__v_529 + __v_762); + let __v_764: G = G::from_u64(256); + let __v_765: G = (__v_764 * __v_534); + let __v_766: G = G::from_u64(65536); + let __v_767: G = (__v_766 * __v_535); + let __v_768: G = G::from_u64(16777216); + let __v_769: G = (__v_768 * __v_536); + let __v_770: G = (__v_767 + __v_769); + let __v_771: G = (__v_765 + __v_770); + let __v_772: G = (__v_533 + __v_771); + if (__v_709 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_709.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_718 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_718.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_727 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_727.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_736 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_736.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_745 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_745.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_754 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_754.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_763 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_763.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); + } + if (__v_772 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_772.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) }); } let __ret: [G; OUT_239] = []; if !unconstrained { record.virt += record.function_queries[239].weight(); } record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); @@ -24875,457 +25013,516 @@ fn aiur_fn_240( let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_384, __v_369]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_385: G = __r_arr[0]; let __v_386: G = __r_arr[1]; - let __v_387: G = G::from_u64(0); - let __v_388: G = { let __values: [G; 10] = [__v_387, __v_370, __v_371, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_380]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_368, __v_388]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; - let __v_389: G = __r_arr[0]; - let __v_390: G = G::from_u64(0); - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_389, __v_379, __v_382, __v_383, __v_385, __v_390]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; - let __v_391: G = __r_arr[0]; - let __v_392: G = G::from_u64(1); - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_389, __v_379, __v_382, __v_383, __v_385, __v_392]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; - let __v_393: G = __r_arr[0]; - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_391, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; - let __v_394: G = __r_arr[0]; - let __v_395: G = __r_arr[1]; - let __v_396: G = __r_arr[2]; - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_393, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; - let __v_397: G = __r_arr[0]; - let __v_398: G = __r_arr[1]; - let __v_399: G = __r_arr[2]; - let __v_400: G = G::from_u64(2); - let __v_401: G = G::from_u64(2); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_401]; let __info = io_buffer.get_info(__v_400, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_402: G = __io_pair.0; - let __v_403: G = __io_pair.1; - let __v_404: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_404, __v_402, __v_403]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; - let __v_405: G = __r_arr[0]; - let __v_406: G = G::from_u64(103); - let __v_407: G = G::from_u64(230); - let __v_408: G = G::from_u64(9); - let __v_409: G = G::from_u64(106); - let __v_410: G = G::from_u64(133); - let __v_411: G = G::from_u64(174); - let __v_412: G = G::from_u64(103); - let __v_413: G = G::from_u64(187); - let __v_414: G = G::from_u64(114); - let __v_415: G = G::from_u64(243); - let __v_416: G = G::from_u64(110); - let __v_417: G = G::from_u64(60); - let __v_418: G = G::from_u64(58); - let __v_419: G = G::from_u64(245); - let __v_420: G = G::from_u64(79); - let __v_421: G = G::from_u64(165); - let __v_422: G = G::from_u64(127); - let __v_423: G = G::from_u64(82); - let __v_424: G = G::from_u64(14); - let __v_425: G = G::from_u64(81); - let __v_426: G = G::from_u64(140); - let __v_427: G = G::from_u64(104); - let __v_428: G = G::from_u64(5); - let __v_429: G = G::from_u64(155); - let __v_430: G = G::from_u64(171); - let __v_431: G = G::from_u64(217); - let __v_432: G = G::from_u64(131); - let __v_433: G = G::from_u64(31); - let __v_434: G = G::from_u64(25); - let __v_435: G = G::from_u64(205); - let __v_436: G = G::from_u64(224); - let __v_437: G = G::from_u64(91); - let __v_438: G = G::from_u64(1); - let __v_439: G = G::from_u64(1); - let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_441: G = G::from_u64(0); - let __v_442: G = G::from_u64(0); - let __v_443: G = G::from_u64(0); - let __v_444: G = G::from_u64(0); - let __v_445: G = G::from_u64(0); - let __v_446: G = G::from_u64(0); - let __v_447: G = G::from_u64(0); - let __v_448: G = G::from_u64(0); - let __v_449: G = G::from_u64(0); - let __v_450: G = G::from_u64(0); - let __v_451: G = { let __values: [G; 8] = [__v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_449, __v_450]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_452: G = { let __values: [G; 32] = [__v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_453: G = G::from_u64(1); - let __v_454: G = G::from_u64(1); - let __v_455: G = { let __values: [G; 34] = [__v_453, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454, __v_454]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_405, __v_440, __v_441, __v_442, __v_451, __v_452, __v_455]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; - let __v_456: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_456]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; - let __v_457: G = __r_arr[0]; - let __v_458: G = __r_arr[1]; - let __v_459: G = __r_arr[2]; - let __v_460: G = __r_arr[3]; - let __v_461: G = __r_arr[4]; - let __v_462: G = __r_arr[5]; - let __v_463: G = __r_arr[6]; - let __v_464: G = __r_arr[7]; - let __v_465: G = __r_arr[8]; - let __v_466: G = __r_arr[9]; - let __v_467: G = __r_arr[10]; - let __v_468: G = __r_arr[11]; - let __v_469: G = __r_arr[12]; - let __v_470: G = __r_arr[13]; - let __v_471: G = __r_arr[14]; - let __v_472: G = __r_arr[15]; - let __v_473: G = __r_arr[16]; - let __v_474: G = __r_arr[17]; - let __v_475: G = __r_arr[18]; - let __v_476: G = __r_arr[19]; - let __v_477: G = __r_arr[20]; - let __v_478: G = __r_arr[21]; - let __v_479: G = __r_arr[22]; - let __v_480: G = __r_arr[23]; - let __v_481: G = __r_arr[24]; - let __v_482: G = __r_arr[25]; - let __v_483: G = __r_arr[26]; - let __v_484: G = __r_arr[27]; - let __v_485: G = __r_arr[28]; - let __v_486: G = __r_arr[29]; - let __v_487: G = __r_arr[30]; - let __v_488: G = __r_arr[31]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_405]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } }; - let __v_489: G = __r_arr[0]; - let __v_490: G = __r_arr[1]; - let __v_491: G = __r_arr[2]; - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_394, __v_397]; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; - let __v_492: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_395, __v_396]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; - let __v_493: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_398, __v_399]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; - let __v_494: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_490, __v_491]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; - let __v_495: G = __r_arr[0]; - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_493, __v_494, __v_489, __v_495]; let __cu = unconstrained; let __hit = record.function_queries[228].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[228].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => aiur_fn_228(__args, record, io_buffer, __cu)? } }; - let __v_496: G = G::from_u64(96); - if (__v_19 != __v_496) { - return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_496.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); - } - let __v_497: G = G::from_u64(256); - let __v_498: G = (__v_497 * __v_74); - let __v_499: G = G::from_u64(65536); - let __v_500: G = (__v_499 * __v_75); - let __v_501: G = G::from_u64(16777216); - let __v_502: G = (__v_501 * __v_76); - let __v_503: G = (__v_500 + __v_502); - let __v_504: G = (__v_498 + __v_503); - let __v_505: G = (__v_73 + __v_504); - let __v_506: G = G::from_u64(256); - let __v_507: G = (__v_506 * __v_78); - let __v_508: G = G::from_u64(65536); - let __v_509: G = (__v_508 * __v_79); - let __v_510: G = G::from_u64(16777216); - let __v_511: G = (__v_510 * __v_80); - let __v_512: G = (__v_509 + __v_511); - let __v_513: G = (__v_507 + __v_512); - let __v_514: G = (__v_77 + __v_513); - let __v_515: G = G::from_u64(256); - let __v_516: G = (__v_515 * __v_82); - let __v_517: G = G::from_u64(65536); - let __v_518: G = (__v_517 * __v_83); - let __v_519: G = G::from_u64(16777216); - let __v_520: G = (__v_519 * __v_84); - let __v_521: G = (__v_518 + __v_520); - let __v_522: G = (__v_516 + __v_521); - let __v_523: G = (__v_81 + __v_522); - let __v_524: G = G::from_u64(256); - let __v_525: G = (__v_524 * __v_86); - let __v_526: G = G::from_u64(65536); - let __v_527: G = (__v_526 * __v_87); - let __v_528: G = G::from_u64(16777216); - let __v_529: G = (__v_528 * __v_88); - let __v_530: G = (__v_527 + __v_529); - let __v_531: G = (__v_525 + __v_530); - let __v_532: G = (__v_85 + __v_531); - let __v_533: G = G::from_u64(256); - let __v_534: G = (__v_533 * __v_90); - let __v_535: G = G::from_u64(65536); - let __v_536: G = (__v_535 * __v_91); - let __v_537: G = G::from_u64(16777216); - let __v_538: G = (__v_537 * __v_92); - let __v_539: G = (__v_536 + __v_538); - let __v_540: G = (__v_534 + __v_539); - let __v_541: G = (__v_89 + __v_540); - let __v_542: G = G::from_u64(256); - let __v_543: G = (__v_542 * __v_94); - let __v_544: G = G::from_u64(65536); - let __v_545: G = (__v_544 * __v_95); - let __v_546: G = G::from_u64(16777216); - let __v_547: G = (__v_546 * __v_96); - let __v_548: G = (__v_545 + __v_547); - let __v_549: G = (__v_543 + __v_548); - let __v_550: G = (__v_93 + __v_549); - let __v_551: G = G::from_u64(256); - let __v_552: G = (__v_551 * __v_98); - let __v_553: G = G::from_u64(65536); - let __v_554: G = (__v_553 * __v_99); - let __v_555: G = G::from_u64(16777216); - let __v_556: G = (__v_555 * __v_100); - let __v_557: G = (__v_554 + __v_556); - let __v_558: G = (__v_552 + __v_557); - let __v_559: G = (__v_97 + __v_558); - let __v_560: G = G::from_u64(256); - let __v_561: G = (__v_560 * __v_102); - let __v_562: G = G::from_u64(65536); - let __v_563: G = (__v_562 * __v_103); - let __v_564: G = G::from_u64(16777216); - let __v_565: G = (__v_564 * __v_104); - let __v_566: G = (__v_563 + __v_565); - let __v_567: G = (__v_561 + __v_566); - let __v_568: G = (__v_101 + __v_567); - if (__v_505 != __v_0) { - return Err(ExecError::AssertEqMismatch { lhs: __v_505.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_514 != __v_1) { - return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_523 != __v_2) { - return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_532 != __v_3) { - return Err(ExecError::AssertEqMismatch { lhs: __v_532.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_541 != __v_4) { - return Err(ExecError::AssertEqMismatch { lhs: __v_541.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_550 != __v_5) { - return Err(ExecError::AssertEqMismatch { lhs: __v_550.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_559 != __v_6) { - return Err(ExecError::AssertEqMismatch { lhs: __v_559.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); - } - if (__v_568 != __v_7) { - return Err(ExecError::AssertEqMismatch { lhs: __v_568.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + let __v_387: G = G::from_u64(1); + let __gb: [u8; 8] = __v_387.as_canonical_u64().to_le_bytes(); + let __v_388: G = G::from_u8(__gb[0]); + let __v_389: G = G::from_u8(__gb[1]); + let __v_390: G = G::from_u8(__gb[2]); + let __v_391: G = G::from_u8(__gb[3]); + let __v_392: G = G::from_u8(__gb[4]); + let __v_393: G = G::from_u8(__gb[5]); + let __v_394: G = G::from_u8(__gb[6]); + let __v_395: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_388; let __vj = __v_389; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_390; let __vj = __v_391; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_392; let __vj = __v_393; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_394; let __vj = __v_395; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_396: G = G::from_u64(1020); + let __v_397: G = (__v_395 - __v_396); + let __v_398: G = (__v_394 + __v_397); + let __v_399: G = (__v_393 + __v_398); + let __v_400: G = (__v_392 + __v_399); + let __v_401: G = G::from_bool((__v_400 == G::ZERO)); + let __v_402: G = (__v_390 + __v_391); + let __v_403: G = (__v_389 + __v_402); + let __v_404: G = (__v_388 + __v_403); + let __v_405: G = G::from_bool((__v_404 == G::ZERO)); + let __v_406: G = G::from_u64(256); + let __v_407: G = (__v_406 * __v_389); + let __v_408: G = G::from_u64(65536); + let __v_409: G = (__v_408 * __v_390); + let __v_410: G = G::from_u64(16777216); + let __v_411: G = (__v_410 * __v_391); + let __v_412: G = G::from_u64(4294967296); + let __v_413: G = (__v_412 * __v_392); + let __v_414: G = G::from_u64(1099511627776); + let __v_415: G = (__v_414 * __v_393); + let __v_416: G = G::from_u64(281474976710656); + let __v_417: G = (__v_416 * __v_394); + let __v_418: G = G::from_u64(72057594037927936); + let __v_419: G = (__v_418 * __v_395); + let __v_420: G = (__v_417 + __v_419); + let __v_421: G = (__v_415 + __v_420); + let __v_422: G = (__v_413 + __v_421); + let __v_423: G = (__v_411 + __v_422); + let __v_424: G = (__v_409 + __v_423); + let __v_425: G = (__v_407 + __v_424); + let __v_426: G = (__v_388 + __v_425); + if (__v_426 != __v_387) { + return Err(ExecError::AssertEqMismatch { lhs: __v_426.as_canonical_u64(), rhs: __v_387.as_canonical_u64(), msg: None }); + } + let __v_427: G = G::from_u64(1); + let __v_428: G = G::from_u64(1); + let __v_429: G = (__v_428 - __v_405); + let __v_430: G = (__v_401 * __v_429); + let __v_431: G = (__v_427 - __v_430); + let __v_432: G = G::from_u64(1); + if (__v_431 != __v_432) { + return Err(ExecError::AssertEqMismatch { lhs: __v_431.as_canonical_u64(), rhs: __v_432.as_canonical_u64(), msg: None }); + } + let __v_433: G = G::from_u64(0); + let __v_434: G = G::from_u64(0); + let __v_435: G = { let __values: [G; 10] = [__v_434, __v_370, __v_371, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_380]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_436: G = { let __values: [G; 10] = [__v_433, __v_388, __v_389, __v_390, __v_391, __v_392, __v_393, __v_394, __v_395, __v_435]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_368, __v_436]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __v_437: G = __r_arr[0]; + let __v_438: G = G::from_u64(0); + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_437, __v_379, __v_382, __v_383, __v_385, __v_438]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __v_439: G = __r_arr[0]; + let __v_440: G = G::from_u64(1); + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_437, __v_379, __v_382, __v_383, __v_385, __v_440]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __v_441: G = __r_arr[0]; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_439, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __v_442: G = __r_arr[0]; + let __v_443: G = __r_arr[1]; + let __v_444: G = __r_arr[2]; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_441, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __v_445: G = __r_arr[0]; + let __v_446: G = __r_arr[1]; + let __v_447: G = __r_arr[2]; + let __v_448: G = G::from_u64(2); + let __v_449: G = G::from_u64(2); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_449]; let __info = io_buffer.get_info(__v_448, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_450: G = __io_pair.0; + let __v_451: G = __io_pair.1; + let __v_452: G = G::from_u64(2); + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_452, __v_450, __v_451]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __v_453: G = __r_arr[0]; + let __v_454: G = G::from_u64(103); + let __v_455: G = G::from_u64(230); + let __v_456: G = G::from_u64(9); + let __v_457: G = G::from_u64(106); + let __v_458: G = G::from_u64(133); + let __v_459: G = G::from_u64(174); + let __v_460: G = G::from_u64(103); + let __v_461: G = G::from_u64(187); + let __v_462: G = G::from_u64(114); + let __v_463: G = G::from_u64(243); + let __v_464: G = G::from_u64(110); + let __v_465: G = G::from_u64(60); + let __v_466: G = G::from_u64(58); + let __v_467: G = G::from_u64(245); + let __v_468: G = G::from_u64(79); + let __v_469: G = G::from_u64(165); + let __v_470: G = G::from_u64(127); + let __v_471: G = G::from_u64(82); + let __v_472: G = G::from_u64(14); + let __v_473: G = G::from_u64(81); + let __v_474: G = G::from_u64(140); + let __v_475: G = G::from_u64(104); + let __v_476: G = G::from_u64(5); + let __v_477: G = G::from_u64(155); + let __v_478: G = G::from_u64(171); + let __v_479: G = G::from_u64(217); + let __v_480: G = G::from_u64(131); + let __v_481: G = G::from_u64(31); + let __v_482: G = G::from_u64(25); + let __v_483: G = G::from_u64(205); + let __v_484: G = G::from_u64(224); + let __v_485: G = G::from_u64(91); + let __v_486: G = G::from_u64(1); + let __v_487: G = G::from_u64(1); + let __v_488: G = { let __values: [G; 3] = [__v_486, __v_487, __v_487]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_489: G = G::from_u64(0); + let __v_490: G = G::from_u64(0); + let __v_491: G = G::from_u64(0); + let __v_492: G = G::from_u64(0); + let __v_493: G = G::from_u64(0); + let __v_494: G = G::from_u64(0); + let __v_495: G = G::from_u64(0); + let __v_496: G = G::from_u64(0); + let __v_497: G = G::from_u64(0); + let __v_498: G = G::from_u64(0); + let __v_499: G = { let __values: [G; 8] = [__v_491, __v_492, __v_493, __v_494, __v_495, __v_496, __v_497, __v_498]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_500: G = { let __values: [G; 32] = [__v_454, __v_455, __v_456, __v_457, __v_458, __v_459, __v_460, __v_461, __v_462, __v_463, __v_464, __v_465, __v_466, __v_467, __v_468, __v_469, __v_470, __v_471, __v_472, __v_473, __v_474, __v_475, __v_476, __v_477, __v_478, __v_479, __v_480, __v_481, __v_482, __v_483, __v_484, __v_485]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_501: G = G::from_u64(1); + let __v_502: G = G::from_u64(1); + let __v_503: G = { let __values: [G; 34] = [__v_501, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_453, __v_488, __v_489, __v_490, __v_499, __v_500, __v_503]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_504: G = __r_arr[0]; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_504]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __v_505: G = __r_arr[0]; + let __v_506: G = __r_arr[1]; + let __v_507: G = __r_arr[2]; + let __v_508: G = __r_arr[3]; + let __v_509: G = __r_arr[4]; + let __v_510: G = __r_arr[5]; + let __v_511: G = __r_arr[6]; + let __v_512: G = __r_arr[7]; + let __v_513: G = __r_arr[8]; + let __v_514: G = __r_arr[9]; + let __v_515: G = __r_arr[10]; + let __v_516: G = __r_arr[11]; + let __v_517: G = __r_arr[12]; + let __v_518: G = __r_arr[13]; + let __v_519: G = __r_arr[14]; + let __v_520: G = __r_arr[15]; + let __v_521: G = __r_arr[16]; + let __v_522: G = __r_arr[17]; + let __v_523: G = __r_arr[18]; + let __v_524: G = __r_arr[19]; + let __v_525: G = __r_arr[20]; + let __v_526: G = __r_arr[21]; + let __v_527: G = __r_arr[22]; + let __v_528: G = __r_arr[23]; + let __v_529: G = __r_arr[24]; + let __v_530: G = __r_arr[25]; + let __v_531: G = __r_arr[26]; + let __v_532: G = __r_arr[27]; + let __v_533: G = __r_arr[28]; + let __v_534: G = __r_arr[29]; + let __v_535: G = __r_arr[30]; + let __v_536: G = __r_arr[31]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_453]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __v_537: G = __r_arr[0]; + let __v_538: G = __r_arr[1]; + let __v_539: G = __r_arr[2]; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_442, __v_445]; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __v_540: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_443, __v_444]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __v_541: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_446, __v_447]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __v_542: G = __r_arr[0]; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_538, __v_539]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __v_543: G = __r_arr[0]; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_541, __v_542, __v_537, __v_543]; let __cu = unconstrained; let __hit = record.function_queries[228].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[228].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __v_544: G = G::from_u64(96); + if (__v_19 != __v_544) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_544.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); + } + let __v_545: G = G::from_u64(256); + let __v_546: G = (__v_545 * __v_74); + let __v_547: G = G::from_u64(65536); + let __v_548: G = (__v_547 * __v_75); + let __v_549: G = G::from_u64(16777216); + let __v_550: G = (__v_549 * __v_76); + let __v_551: G = (__v_548 + __v_550); + let __v_552: G = (__v_546 + __v_551); + let __v_553: G = (__v_73 + __v_552); + let __v_554: G = G::from_u64(256); + let __v_555: G = (__v_554 * __v_78); + let __v_556: G = G::from_u64(65536); + let __v_557: G = (__v_556 * __v_79); + let __v_558: G = G::from_u64(16777216); + let __v_559: G = (__v_558 * __v_80); + let __v_560: G = (__v_557 + __v_559); + let __v_561: G = (__v_555 + __v_560); + let __v_562: G = (__v_77 + __v_561); + let __v_563: G = G::from_u64(256); + let __v_564: G = (__v_563 * __v_82); + let __v_565: G = G::from_u64(65536); + let __v_566: G = (__v_565 * __v_83); + let __v_567: G = G::from_u64(16777216); + let __v_568: G = (__v_567 * __v_84); + let __v_569: G = (__v_566 + __v_568); + let __v_570: G = (__v_564 + __v_569); + let __v_571: G = (__v_81 + __v_570); + let __v_572: G = G::from_u64(256); + let __v_573: G = (__v_572 * __v_86); + let __v_574: G = G::from_u64(65536); + let __v_575: G = (__v_574 * __v_87); + let __v_576: G = G::from_u64(16777216); + let __v_577: G = (__v_576 * __v_88); + let __v_578: G = (__v_575 + __v_577); + let __v_579: G = (__v_573 + __v_578); + let __v_580: G = (__v_85 + __v_579); + let __v_581: G = G::from_u64(256); + let __v_582: G = (__v_581 * __v_90); + let __v_583: G = G::from_u64(65536); + let __v_584: G = (__v_583 * __v_91); + let __v_585: G = G::from_u64(16777216); + let __v_586: G = (__v_585 * __v_92); + let __v_587: G = (__v_584 + __v_586); + let __v_588: G = (__v_582 + __v_587); + let __v_589: G = (__v_89 + __v_588); + let __v_590: G = G::from_u64(256); + let __v_591: G = (__v_590 * __v_94); + let __v_592: G = G::from_u64(65536); + let __v_593: G = (__v_592 * __v_95); + let __v_594: G = G::from_u64(16777216); + let __v_595: G = (__v_594 * __v_96); + let __v_596: G = (__v_593 + __v_595); + let __v_597: G = (__v_591 + __v_596); + let __v_598: G = (__v_93 + __v_597); + let __v_599: G = G::from_u64(256); + let __v_600: G = (__v_599 * __v_98); + let __v_601: G = G::from_u64(65536); + let __v_602: G = (__v_601 * __v_99); + let __v_603: G = G::from_u64(16777216); + let __v_604: G = (__v_603 * __v_100); + let __v_605: G = (__v_602 + __v_604); + let __v_606: G = (__v_600 + __v_605); + let __v_607: G = (__v_97 + __v_606); + let __v_608: G = G::from_u64(256); + let __v_609: G = (__v_608 * __v_102); + let __v_610: G = G::from_u64(65536); + let __v_611: G = (__v_610 * __v_103); + let __v_612: G = G::from_u64(16777216); + let __v_613: G = (__v_612 * __v_104); + let __v_614: G = (__v_611 + __v_613); + let __v_615: G = (__v_609 + __v_614); + let __v_616: G = (__v_101 + __v_615); + if (__v_553 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_553.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_562 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_562.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_571 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_571.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_580 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_580.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_589 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_589.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_598 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_598.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_607 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_607.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); + } + if (__v_616 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_616.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) }); } let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_172.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_569: G = __loaded[0]; - let __v_570: G = __loaded[1]; - let __v_571: G = __loaded[2]; - let __v_572: G = G::from_u64(1); - let __v_573: G = G::from_u64(1); - if (__v_569 != __v_572) { - return Err(ExecError::AssertEqMismatch { lhs: __v_569.as_canonical_u64(), rhs: __v_572.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); - } - if (__v_570 != __v_573) { - return Err(ExecError::AssertEqMismatch { lhs: __v_570.as_canonical_u64(), rhs: __v_573.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); - } - if (__v_571 != __v_573) { - return Err(ExecError::AssertEqMismatch { lhs: __v_571.as_canonical_u64(), rhs: __v_573.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); - } - let __v_574: G = G::from_u64(256); - let __v_575: G = (__v_574 * __v_251); - let __v_576: G = G::from_u64(65536); - let __v_577: G = (__v_576 * __v_252); - let __v_578: G = G::from_u64(16777216); - let __v_579: G = (__v_578 * __v_253); - let __v_580: G = (__v_577 + __v_579); - let __v_581: G = (__v_575 + __v_580); - let __v_582: G = (__v_250 + __v_581); - let __v_583: G = G::from_u64(256); - let __v_584: G = (__v_583 * __v_255); - let __v_585: G = G::from_u64(65536); - let __v_586: G = (__v_585 * __v_256); - let __v_587: G = G::from_u64(16777216); - let __v_588: G = (__v_587 * __v_257); - let __v_589: G = (__v_586 + __v_588); - let __v_590: G = (__v_584 + __v_589); - let __v_591: G = (__v_254 + __v_590); - let __v_592: G = G::from_u64(256); - let __v_593: G = (__v_592 * __v_259); - let __v_594: G = G::from_u64(65536); - let __v_595: G = (__v_594 * __v_260); - let __v_596: G = G::from_u64(16777216); - let __v_597: G = (__v_596 * __v_261); - let __v_598: G = (__v_595 + __v_597); - let __v_599: G = (__v_593 + __v_598); - let __v_600: G = (__v_258 + __v_599); - let __v_601: G = G::from_u64(256); - let __v_602: G = (__v_601 * __v_263); - let __v_603: G = G::from_u64(65536); - let __v_604: G = (__v_603 * __v_264); - let __v_605: G = G::from_u64(16777216); - let __v_606: G = (__v_605 * __v_265); - let __v_607: G = (__v_604 + __v_606); - let __v_608: G = (__v_602 + __v_607); - let __v_609: G = (__v_262 + __v_608); - let __v_610: G = G::from_u64(256); - let __v_611: G = (__v_610 * __v_267); - let __v_612: G = G::from_u64(65536); - let __v_613: G = (__v_612 * __v_268); - let __v_614: G = G::from_u64(16777216); - let __v_615: G = (__v_614 * __v_269); - let __v_616: G = (__v_613 + __v_615); - let __v_617: G = (__v_611 + __v_616); - let __v_618: G = (__v_266 + __v_617); - let __v_619: G = G::from_u64(256); - let __v_620: G = (__v_619 * __v_271); - let __v_621: G = G::from_u64(65536); - let __v_622: G = (__v_621 * __v_272); - let __v_623: G = G::from_u64(16777216); - let __v_624: G = (__v_623 * __v_273); - let __v_625: G = (__v_622 + __v_624); - let __v_626: G = (__v_620 + __v_625); - let __v_627: G = (__v_270 + __v_626); - let __v_628: G = G::from_u64(256); - let __v_629: G = (__v_628 * __v_275); - let __v_630: G = G::from_u64(65536); - let __v_631: G = (__v_630 * __v_276); - let __v_632: G = G::from_u64(16777216); - let __v_633: G = (__v_632 * __v_277); - let __v_634: G = (__v_631 + __v_633); - let __v_635: G = (__v_629 + __v_634); - let __v_636: G = (__v_274 + __v_635); - let __v_637: G = G::from_u64(256); - let __v_638: G = (__v_637 * __v_279); - let __v_639: G = G::from_u64(65536); - let __v_640: G = (__v_639 * __v_280); - let __v_641: G = G::from_u64(16777216); - let __v_642: G = (__v_641 * __v_281); - let __v_643: G = (__v_640 + __v_642); - let __v_644: G = (__v_638 + __v_643); - let __v_645: G = (__v_278 + __v_644); - if (__v_582 != __v_181) { - return Err(ExecError::AssertEqMismatch { lhs: __v_582.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_591 != __v_182) { - return Err(ExecError::AssertEqMismatch { lhs: __v_591.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_600 != __v_183) { - return Err(ExecError::AssertEqMismatch { lhs: __v_600.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_609 != __v_184) { - return Err(ExecError::AssertEqMismatch { lhs: __v_609.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_618 != __v_185) { - return Err(ExecError::AssertEqMismatch { lhs: __v_618.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_627 != __v_186) { - return Err(ExecError::AssertEqMismatch { lhs: __v_627.as_canonical_u64(), rhs: __v_186.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_636 != __v_187) { - return Err(ExecError::AssertEqMismatch { lhs: __v_636.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); - } - if (__v_645 != __v_188) { - return Err(ExecError::AssertEqMismatch { lhs: __v_645.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + let __v_617: G = __loaded[0]; + let __v_618: G = __loaded[1]; + let __v_619: G = __loaded[2]; + let __v_620: G = G::from_u64(1); + let __v_621: G = G::from_u64(1); + if (__v_617 != __v_620) { + return Err(ExecError::AssertEqMismatch { lhs: __v_617.as_canonical_u64(), rhs: __v_620.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); + } + if (__v_618 != __v_621) { + return Err(ExecError::AssertEqMismatch { lhs: __v_618.as_canonical_u64(), rhs: __v_621.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); + } + if (__v_619 != __v_621) { + return Err(ExecError::AssertEqMismatch { lhs: __v_619.as_canonical_u64(), rhs: __v_621.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) }); + } + let __v_622: G = G::from_u64(256); + let __v_623: G = (__v_622 * __v_251); + let __v_624: G = G::from_u64(65536); + let __v_625: G = (__v_624 * __v_252); + let __v_626: G = G::from_u64(16777216); + let __v_627: G = (__v_626 * __v_253); + let __v_628: G = (__v_625 + __v_627); + let __v_629: G = (__v_623 + __v_628); + let __v_630: G = (__v_250 + __v_629); + let __v_631: G = G::from_u64(256); + let __v_632: G = (__v_631 * __v_255); + let __v_633: G = G::from_u64(65536); + let __v_634: G = (__v_633 * __v_256); + let __v_635: G = G::from_u64(16777216); + let __v_636: G = (__v_635 * __v_257); + let __v_637: G = (__v_634 + __v_636); + let __v_638: G = (__v_632 + __v_637); + let __v_639: G = (__v_254 + __v_638); + let __v_640: G = G::from_u64(256); + let __v_641: G = (__v_640 * __v_259); + let __v_642: G = G::from_u64(65536); + let __v_643: G = (__v_642 * __v_260); + let __v_644: G = G::from_u64(16777216); + let __v_645: G = (__v_644 * __v_261); + let __v_646: G = (__v_643 + __v_645); + let __v_647: G = (__v_641 + __v_646); + let __v_648: G = (__v_258 + __v_647); + let __v_649: G = G::from_u64(256); + let __v_650: G = (__v_649 * __v_263); + let __v_651: G = G::from_u64(65536); + let __v_652: G = (__v_651 * __v_264); + let __v_653: G = G::from_u64(16777216); + let __v_654: G = (__v_653 * __v_265); + let __v_655: G = (__v_652 + __v_654); + let __v_656: G = (__v_650 + __v_655); + let __v_657: G = (__v_262 + __v_656); + let __v_658: G = G::from_u64(256); + let __v_659: G = (__v_658 * __v_267); + let __v_660: G = G::from_u64(65536); + let __v_661: G = (__v_660 * __v_268); + let __v_662: G = G::from_u64(16777216); + let __v_663: G = (__v_662 * __v_269); + let __v_664: G = (__v_661 + __v_663); + let __v_665: G = (__v_659 + __v_664); + let __v_666: G = (__v_266 + __v_665); + let __v_667: G = G::from_u64(256); + let __v_668: G = (__v_667 * __v_271); + let __v_669: G = G::from_u64(65536); + let __v_670: G = (__v_669 * __v_272); + let __v_671: G = G::from_u64(16777216); + let __v_672: G = (__v_671 * __v_273); + let __v_673: G = (__v_670 + __v_672); + let __v_674: G = (__v_668 + __v_673); + let __v_675: G = (__v_270 + __v_674); + let __v_676: G = G::from_u64(256); + let __v_677: G = (__v_676 * __v_275); + let __v_678: G = G::from_u64(65536); + let __v_679: G = (__v_678 * __v_276); + let __v_680: G = G::from_u64(16777216); + let __v_681: G = (__v_680 * __v_277); + let __v_682: G = (__v_679 + __v_681); + let __v_683: G = (__v_677 + __v_682); + let __v_684: G = (__v_274 + __v_683); + let __v_685: G = G::from_u64(256); + let __v_686: G = (__v_685 * __v_279); + let __v_687: G = G::from_u64(65536); + let __v_688: G = (__v_687 * __v_280); + let __v_689: G = G::from_u64(16777216); + let __v_690: G = (__v_689 * __v_281); + let __v_691: G = (__v_688 + __v_690); + let __v_692: G = (__v_686 + __v_691); + let __v_693: G = (__v_278 + __v_692); + if (__v_630 != __v_181) { + return Err(ExecError::AssertEqMismatch { lhs: __v_630.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_639 != __v_182) { + return Err(ExecError::AssertEqMismatch { lhs: __v_639.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_648 != __v_183) { + return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_657 != __v_184) { + return Err(ExecError::AssertEqMismatch { lhs: __v_657.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_666 != __v_185) { + return Err(ExecError::AssertEqMismatch { lhs: __v_666.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_675 != __v_186) { + return Err(ExecError::AssertEqMismatch { lhs: __v_675.as_canonical_u64(), rhs: __v_186.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_684 != __v_187) { + return Err(ExecError::AssertEqMismatch { lhs: __v_684.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); + } + if (__v_693 != __v_188) { + return Err(ExecError::AssertEqMismatch { lhs: __v_693.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) }); } let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_386.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_646: G = __loaded[0]; - let __v_647: G = __loaded[1]; - let __v_648: G = __loaded[2]; - let __v_649: G = G::from_u64(1); - let __v_650: G = G::from_u64(1); - if (__v_646 != __v_649) { - return Err(ExecError::AssertEqMismatch { lhs: __v_646.as_canonical_u64(), rhs: __v_649.as_canonical_u64(), msg: None }); - } - if (__v_647 != __v_650) { - return Err(ExecError::AssertEqMismatch { lhs: __v_647.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: None }); - } - if (__v_648 != __v_650) { - return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: None }); - } - let __v_651: G = G::from_u64(256); - let __v_652: G = (__v_651 * __v_458); - let __v_653: G = G::from_u64(65536); - let __v_654: G = (__v_653 * __v_459); - let __v_655: G = G::from_u64(16777216); - let __v_656: G = (__v_655 * __v_460); - let __v_657: G = (__v_654 + __v_656); - let __v_658: G = (__v_652 + __v_657); - let __v_659: G = (__v_457 + __v_658); - let __v_660: G = G::from_u64(256); - let __v_661: G = (__v_660 * __v_462); - let __v_662: G = G::from_u64(65536); - let __v_663: G = (__v_662 * __v_463); - let __v_664: G = G::from_u64(16777216); - let __v_665: G = (__v_664 * __v_464); - let __v_666: G = (__v_663 + __v_665); - let __v_667: G = (__v_661 + __v_666); - let __v_668: G = (__v_461 + __v_667); - let __v_669: G = G::from_u64(256); - let __v_670: G = (__v_669 * __v_466); - let __v_671: G = G::from_u64(65536); - let __v_672: G = (__v_671 * __v_467); - let __v_673: G = G::from_u64(16777216); - let __v_674: G = (__v_673 * __v_468); - let __v_675: G = (__v_672 + __v_674); - let __v_676: G = (__v_670 + __v_675); - let __v_677: G = (__v_465 + __v_676); - let __v_678: G = G::from_u64(256); - let __v_679: G = (__v_678 * __v_470); - let __v_680: G = G::from_u64(65536); - let __v_681: G = (__v_680 * __v_471); - let __v_682: G = G::from_u64(16777216); - let __v_683: G = (__v_682 * __v_472); - let __v_684: G = (__v_681 + __v_683); - let __v_685: G = (__v_679 + __v_684); - let __v_686: G = (__v_469 + __v_685); - let __v_687: G = G::from_u64(256); - let __v_688: G = (__v_687 * __v_474); - let __v_689: G = G::from_u64(65536); - let __v_690: G = (__v_689 * __v_475); - let __v_691: G = G::from_u64(16777216); - let __v_692: G = (__v_691 * __v_476); - let __v_693: G = (__v_690 + __v_692); - let __v_694: G = (__v_688 + __v_693); - let __v_695: G = (__v_473 + __v_694); - let __v_696: G = G::from_u64(256); - let __v_697: G = (__v_696 * __v_478); - let __v_698: G = G::from_u64(65536); - let __v_699: G = (__v_698 * __v_479); - let __v_700: G = G::from_u64(16777216); - let __v_701: G = (__v_700 * __v_480); - let __v_702: G = (__v_699 + __v_701); - let __v_703: G = (__v_697 + __v_702); - let __v_704: G = (__v_477 + __v_703); - let __v_705: G = G::from_u64(256); - let __v_706: G = (__v_705 * __v_482); - let __v_707: G = G::from_u64(65536); - let __v_708: G = (__v_707 * __v_483); - let __v_709: G = G::from_u64(16777216); - let __v_710: G = (__v_709 * __v_484); - let __v_711: G = (__v_708 + __v_710); - let __v_712: G = (__v_706 + __v_711); - let __v_713: G = (__v_481 + __v_712); - let __v_714: G = G::from_u64(256); - let __v_715: G = (__v_714 * __v_486); - let __v_716: G = G::from_u64(65536); - let __v_717: G = (__v_716 * __v_487); - let __v_718: G = G::from_u64(16777216); - let __v_719: G = (__v_718 * __v_488); - let __v_720: G = (__v_717 + __v_719); - let __v_721: G = (__v_715 + __v_720); - let __v_722: G = (__v_485 + __v_721); - if (__v_659 != __v_8) { - return Err(ExecError::AssertEqMismatch { lhs: __v_659.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_668 != __v_9) { - return Err(ExecError::AssertEqMismatch { lhs: __v_668.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_677 != __v_10) { - return Err(ExecError::AssertEqMismatch { lhs: __v_677.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_686 != __v_11) { - return Err(ExecError::AssertEqMismatch { lhs: __v_686.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_695 != __v_12) { - return Err(ExecError::AssertEqMismatch { lhs: __v_695.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_704 != __v_13) { - return Err(ExecError::AssertEqMismatch { lhs: __v_704.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_713 != __v_14) { - return Err(ExecError::AssertEqMismatch { lhs: __v_713.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - if (__v_722 != __v_15) { - return Err(ExecError::AssertEqMismatch { lhs: __v_722.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); - } - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_489, __v_492]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; - let __v_723: G = __r_arr[0]; - let __v_724: G = G::from_u64(1); - if (__v_723 != __v_724) { - return Err(ExecError::AssertEqMismatch { lhs: __v_723.as_canonical_u64(), rhs: __v_724.as_canonical_u64(), msg: Some("structural join: output subject root is not nodeHash(left, right)".to_string()) }); + let __v_694: G = __loaded[0]; + let __v_695: G = __loaded[1]; + let __v_696: G = __loaded[2]; + let __v_697: G = G::from_u64(1); + let __v_698: G = G::from_u64(1); + if (__v_694 != __v_697) { + return Err(ExecError::AssertEqMismatch { lhs: __v_694.as_canonical_u64(), rhs: __v_697.as_canonical_u64(), msg: None }); + } + if (__v_695 != __v_698) { + return Err(ExecError::AssertEqMismatch { lhs: __v_695.as_canonical_u64(), rhs: __v_698.as_canonical_u64(), msg: None }); + } + if (__v_696 != __v_698) { + return Err(ExecError::AssertEqMismatch { lhs: __v_696.as_canonical_u64(), rhs: __v_698.as_canonical_u64(), msg: None }); + } + let __v_699: G = G::from_u64(256); + let __v_700: G = (__v_699 * __v_506); + let __v_701: G = G::from_u64(65536); + let __v_702: G = (__v_701 * __v_507); + let __v_703: G = G::from_u64(16777216); + let __v_704: G = (__v_703 * __v_508); + let __v_705: G = (__v_702 + __v_704); + let __v_706: G = (__v_700 + __v_705); + let __v_707: G = (__v_505 + __v_706); + let __v_708: G = G::from_u64(256); + let __v_709: G = (__v_708 * __v_510); + let __v_710: G = G::from_u64(65536); + let __v_711: G = (__v_710 * __v_511); + let __v_712: G = G::from_u64(16777216); + let __v_713: G = (__v_712 * __v_512); + let __v_714: G = (__v_711 + __v_713); + let __v_715: G = (__v_709 + __v_714); + let __v_716: G = (__v_509 + __v_715); + let __v_717: G = G::from_u64(256); + let __v_718: G = (__v_717 * __v_514); + let __v_719: G = G::from_u64(65536); + let __v_720: G = (__v_719 * __v_515); + let __v_721: G = G::from_u64(16777216); + let __v_722: G = (__v_721 * __v_516); + let __v_723: G = (__v_720 + __v_722); + let __v_724: G = (__v_718 + __v_723); + let __v_725: G = (__v_513 + __v_724); + let __v_726: G = G::from_u64(256); + let __v_727: G = (__v_726 * __v_518); + let __v_728: G = G::from_u64(65536); + let __v_729: G = (__v_728 * __v_519); + let __v_730: G = G::from_u64(16777216); + let __v_731: G = (__v_730 * __v_520); + let __v_732: G = (__v_729 + __v_731); + let __v_733: G = (__v_727 + __v_732); + let __v_734: G = (__v_517 + __v_733); + let __v_735: G = G::from_u64(256); + let __v_736: G = (__v_735 * __v_522); + let __v_737: G = G::from_u64(65536); + let __v_738: G = (__v_737 * __v_523); + let __v_739: G = G::from_u64(16777216); + let __v_740: G = (__v_739 * __v_524); + let __v_741: G = (__v_738 + __v_740); + let __v_742: G = (__v_736 + __v_741); + let __v_743: G = (__v_521 + __v_742); + let __v_744: G = G::from_u64(256); + let __v_745: G = (__v_744 * __v_526); + let __v_746: G = G::from_u64(65536); + let __v_747: G = (__v_746 * __v_527); + let __v_748: G = G::from_u64(16777216); + let __v_749: G = (__v_748 * __v_528); + let __v_750: G = (__v_747 + __v_749); + let __v_751: G = (__v_745 + __v_750); + let __v_752: G = (__v_525 + __v_751); + let __v_753: G = G::from_u64(256); + let __v_754: G = (__v_753 * __v_530); + let __v_755: G = G::from_u64(65536); + let __v_756: G = (__v_755 * __v_531); + let __v_757: G = G::from_u64(16777216); + let __v_758: G = (__v_757 * __v_532); + let __v_759: G = (__v_756 + __v_758); + let __v_760: G = (__v_754 + __v_759); + let __v_761: G = (__v_529 + __v_760); + let __v_762: G = G::from_u64(256); + let __v_763: G = (__v_762 * __v_534); + let __v_764: G = G::from_u64(65536); + let __v_765: G = (__v_764 * __v_535); + let __v_766: G = G::from_u64(16777216); + let __v_767: G = (__v_766 * __v_536); + let __v_768: G = (__v_765 + __v_767); + let __v_769: G = (__v_763 + __v_768); + let __v_770: G = (__v_533 + __v_769); + if (__v_707 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_707.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_716 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_716.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_725 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_725.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_734 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_734.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_743 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_743.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_752 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_752.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_761 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_761.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + if (__v_770 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_770.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); + } + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_537, __v_540]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_771: G = __r_arr[0]; + let __v_772: G = G::from_u64(1); + if (__v_771 != __v_772) { + return Err(ExecError::AssertEqMismatch { lhs: __v_771.as_canonical_u64(), rhs: __v_772.as_canonical_u64(), msg: Some("structural join: output subject root is not nodeHash(left, right)".to_string()) }); } let __ret: [G; OUT_240] = []; if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); @@ -25645,145 +25842,204 @@ fn aiur_fn_241( let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_261, __v_246]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; let __v_263: G = __r_arr[1]; - let __v_264: G = G::from_u64(0); - let __v_265: G = { let __values: [G; 10] = [__v_264, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_257]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_245, __v_265]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; - let __v_266: G = __r_arr[0]; - let __v_267: G = G::from_u64(2); - let __v_268: G = G::from_u64(0); - let __io_pair: (G, G) = { let __key: [G; 1] = [__v_268]; let __info = io_buffer.get_info(__v_267, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; - let __v_269: G = __io_pair.0; - let __v_270: G = __io_pair.1; - let __v_271: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_271, __v_269, __v_270]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; - let __v_272: G = __r_arr[0]; - let __v_273: G = G::from_u64(103); - let __v_274: G = G::from_u64(230); - let __v_275: G = G::from_u64(9); - let __v_276: G = G::from_u64(106); - let __v_277: G = G::from_u64(133); - let __v_278: G = G::from_u64(174); - let __v_279: G = G::from_u64(103); - let __v_280: G = G::from_u64(187); - let __v_281: G = G::from_u64(114); - let __v_282: G = G::from_u64(243); - let __v_283: G = G::from_u64(110); - let __v_284: G = G::from_u64(60); - let __v_285: G = G::from_u64(58); - let __v_286: G = G::from_u64(245); - let __v_287: G = G::from_u64(79); - let __v_288: G = G::from_u64(165); - let __v_289: G = G::from_u64(127); - let __v_290: G = G::from_u64(82); - let __v_291: G = G::from_u64(14); - let __v_292: G = G::from_u64(81); - let __v_293: G = G::from_u64(140); - let __v_294: G = G::from_u64(104); - let __v_295: G = G::from_u64(5); - let __v_296: G = G::from_u64(155); - let __v_297: G = G::from_u64(171); - let __v_298: G = G::from_u64(217); - let __v_299: G = G::from_u64(131); - let __v_300: G = G::from_u64(31); - let __v_301: G = G::from_u64(25); - let __v_302: G = G::from_u64(205); - let __v_303: G = G::from_u64(224); - let __v_304: G = G::from_u64(91); + let __v_264: G = G::from_u64(1); + let __gb: [u8; 8] = __v_264.as_canonical_u64().to_le_bytes(); + let __v_265: G = G::from_u8(__gb[0]); + let __v_266: G = G::from_u8(__gb[1]); + let __v_267: G = G::from_u8(__gb[2]); + let __v_268: G = G::from_u8(__gb[3]); + let __v_269: G = G::from_u8(__gb[4]); + let __v_270: G = G::from_u8(__gb[5]); + let __v_271: G = G::from_u8(__gb[6]); + let __v_272: G = G::from_u8(__gb[7]); + if !unconstrained { let __vi = __v_265; let __vj = __v_266; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_267; let __vj = __v_268; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_269; let __vj = __v_270; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_271; let __vj = __v_272; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + let __v_273: G = G::from_u64(1020); + let __v_274: G = (__v_272 - __v_273); + let __v_275: G = (__v_271 + __v_274); + let __v_276: G = (__v_270 + __v_275); + let __v_277: G = (__v_269 + __v_276); + let __v_278: G = G::from_bool((__v_277 == G::ZERO)); + let __v_279: G = (__v_267 + __v_268); + let __v_280: G = (__v_266 + __v_279); + let __v_281: G = (__v_265 + __v_280); + let __v_282: G = G::from_bool((__v_281 == G::ZERO)); + let __v_283: G = G::from_u64(256); + let __v_284: G = (__v_283 * __v_266); + let __v_285: G = G::from_u64(65536); + let __v_286: G = (__v_285 * __v_267); + let __v_287: G = G::from_u64(16777216); + let __v_288: G = (__v_287 * __v_268); + let __v_289: G = G::from_u64(4294967296); + let __v_290: G = (__v_289 * __v_269); + let __v_291: G = G::from_u64(1099511627776); + let __v_292: G = (__v_291 * __v_270); + let __v_293: G = G::from_u64(281474976710656); + let __v_294: G = (__v_293 * __v_271); + let __v_295: G = G::from_u64(72057594037927936); + let __v_296: G = (__v_295 * __v_272); + let __v_297: G = (__v_294 + __v_296); + let __v_298: G = (__v_292 + __v_297); + let __v_299: G = (__v_290 + __v_298); + let __v_300: G = (__v_288 + __v_299); + let __v_301: G = (__v_286 + __v_300); + let __v_302: G = (__v_284 + __v_301); + let __v_303: G = (__v_265 + __v_302); + if (__v_303 != __v_264) { + return Err(ExecError::AssertEqMismatch { lhs: __v_303.as_canonical_u64(), rhs: __v_264.as_canonical_u64(), msg: None }); + } + let __v_304: G = G::from_u64(1); let __v_305: G = G::from_u64(1); - let __v_306: G = G::from_u64(1); - let __v_307: G = { let __values: [G; 3] = [__v_305, __v_306, __v_306]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_308: G = G::from_u64(0); - let __v_309: G = G::from_u64(0); + let __v_306: G = (__v_305 - __v_282); + let __v_307: G = (__v_278 * __v_306); + let __v_308: G = (__v_304 - __v_307); + let __v_309: G = G::from_u64(1); + if (__v_308 != __v_309) { + return Err(ExecError::AssertEqMismatch { lhs: __v_308.as_canonical_u64(), rhs: __v_309.as_canonical_u64(), msg: None }); + } let __v_310: G = G::from_u64(0); let __v_311: G = G::from_u64(0); - let __v_312: G = G::from_u64(0); - let __v_313: G = G::from_u64(0); - let __v_314: G = G::from_u64(0); - let __v_315: G = G::from_u64(0); + let __v_312: G = { let __values: [G; 10] = [__v_311, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_257]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_313: G = { let __values: [G; 10] = [__v_310, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_312]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_245, __v_313]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __v_314: G = __r_arr[0]; + let __v_315: G = G::from_u64(2); let __v_316: G = G::from_u64(0); - let __v_317: G = G::from_u64(0); - let __v_318: G = { let __values: [G; 8] = [__v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_319: G = { let __values: [G; 32] = [__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, __v_301, __v_302, __v_303, __v_304]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_320: G = G::from_u64(1); - let __v_321: G = G::from_u64(1); - let __v_322: G = { let __values: [G; 34] = [__v_320, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_272, __v_307, __v_308, __v_309, __v_318, __v_319, __v_322]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; - let __v_323: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_323]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; - let __v_324: G = __r_arr[0]; - let __v_325: G = __r_arr[1]; - let __v_326: G = __r_arr[2]; - let __v_327: G = __r_arr[3]; - let __v_328: G = __r_arr[4]; - let __v_329: G = __r_arr[5]; - let __v_330: G = __r_arr[6]; - let __v_331: G = __r_arr[7]; - let __v_332: G = __r_arr[8]; - let __v_333: G = __r_arr[9]; - let __v_334: G = __r_arr[10]; - let __v_335: G = __r_arr[11]; - let __v_336: G = __r_arr[12]; - let __v_337: G = __r_arr[13]; - let __v_338: G = __r_arr[14]; - let __v_339: G = __r_arr[15]; - let __v_340: G = __r_arr[16]; - let __v_341: G = __r_arr[17]; - let __v_342: G = __r_arr[18]; - let __v_343: G = __r_arr[19]; - let __v_344: G = __r_arr[20]; - let __v_345: G = __r_arr[21]; - let __v_346: G = __r_arr[22]; - let __v_347: G = __r_arr[23]; - let __v_348: G = __r_arr[24]; - let __v_349: G = __r_arr[25]; - let __v_350: G = __r_arr[26]; - let __v_351: G = __r_arr[27]; - let __v_352: G = __r_arr[28]; - let __v_353: G = __r_arr[29]; - let __v_354: G = __r_arr[30]; - let __v_355: G = __r_arr[31]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_272]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; - let __v_356: G = __r_arr[0]; - let __v_357: G = __r_arr[1]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_357, __v_356]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_358: G = __r_arr[0]; - let __v_359: G = __r_arr[1]; + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_316]; let __info = io_buffer.get_info(__v_315, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_317: G = __io_pair.0; + let __v_318: G = __io_pair.1; + let __v_319: G = G::from_u64(2); + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_319, __v_317, __v_318]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __v_320: G = __r_arr[0]; + let __v_321: G = G::from_u64(103); + let __v_322: G = G::from_u64(230); + let __v_323: G = G::from_u64(9); + let __v_324: G = G::from_u64(106); + let __v_325: G = G::from_u64(133); + let __v_326: G = G::from_u64(174); + let __v_327: G = G::from_u64(103); + let __v_328: G = G::from_u64(187); + let __v_329: G = G::from_u64(114); + let __v_330: G = G::from_u64(243); + let __v_331: G = G::from_u64(110); + let __v_332: G = G::from_u64(60); + let __v_333: G = G::from_u64(58); + let __v_334: G = G::from_u64(245); + let __v_335: G = G::from_u64(79); + let __v_336: G = G::from_u64(165); + let __v_337: G = G::from_u64(127); + let __v_338: G = G::from_u64(82); + let __v_339: G = G::from_u64(14); + let __v_340: G = G::from_u64(81); + let __v_341: G = G::from_u64(140); + let __v_342: G = G::from_u64(104); + let __v_343: G = G::from_u64(5); + let __v_344: G = G::from_u64(155); + let __v_345: G = G::from_u64(171); + let __v_346: G = G::from_u64(217); + let __v_347: G = G::from_u64(131); + let __v_348: G = G::from_u64(31); + let __v_349: G = G::from_u64(25); + let __v_350: G = G::from_u64(205); + let __v_351: G = G::from_u64(224); + let __v_352: G = G::from_u64(91); + let __v_353: G = G::from_u64(1); + let __v_354: G = G::from_u64(1); + let __v_355: G = { let __values: [G; 3] = [__v_353, __v_354, __v_354]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_356: G = G::from_u64(0); + let __v_357: G = G::from_u64(0); + let __v_358: G = G::from_u64(0); + let __v_359: G = G::from_u64(0); + let __v_360: G = G::from_u64(0); + let __v_361: G = G::from_u64(0); + let __v_362: G = G::from_u64(0); + let __v_363: G = G::from_u64(0); + let __v_364: G = G::from_u64(0); + let __v_365: G = G::from_u64(0); + let __v_366: G = { let __values: [G; 8] = [__v_358, __v_359, __v_360, __v_361, __v_362, __v_363, __v_364, __v_365]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_367: G = { let __values: [G; 32] = [__v_321, __v_322, __v_323, __v_324, __v_325, __v_326, __v_327, __v_328, __v_329, __v_330, __v_331, __v_332, __v_333, __v_334, __v_335, __v_336, __v_337, __v_338, __v_339, __v_340, __v_341, __v_342, __v_343, __v_344, __v_345, __v_346, __v_347, __v_348, __v_349, __v_350, __v_351, __v_352]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_368: G = G::from_u64(1); + let __v_369: G = G::from_u64(1); + let __v_370: G = { let __values: [G; 34] = [__v_368, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_320, __v_355, __v_356, __v_357, __v_366, __v_367, __v_370]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_371: G = __r_arr[0]; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_371]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __v_372: G = __r_arr[0]; + let __v_373: G = __r_arr[1]; + let __v_374: G = __r_arr[2]; + let __v_375: G = __r_arr[3]; + let __v_376: G = __r_arr[4]; + let __v_377: G = __r_arr[5]; + let __v_378: G = __r_arr[6]; + let __v_379: G = __r_arr[7]; + let __v_380: G = __r_arr[8]; + let __v_381: G = __r_arr[9]; + let __v_382: G = __r_arr[10]; + let __v_383: G = __r_arr[11]; + let __v_384: G = __r_arr[12]; + let __v_385: G = __r_arr[13]; + let __v_386: G = __r_arr[14]; + let __v_387: G = __r_arr[15]; + let __v_388: G = __r_arr[16]; + let __v_389: G = __r_arr[17]; + let __v_390: G = __r_arr[18]; + let __v_391: G = __r_arr[19]; + let __v_392: G = __r_arr[20]; + let __v_393: G = __r_arr[21]; + let __v_394: G = __r_arr[22]; + let __v_395: G = __r_arr[23]; + let __v_396: G = __r_arr[24]; + let __v_397: G = __r_arr[25]; + let __v_398: G = __r_arr[26]; + let __v_399: G = __r_arr[27]; + let __v_400: G = __r_arr[28]; + let __v_401: G = __r_arr[29]; + let __v_402: G = __r_arr[30]; + let __v_403: G = __r_arr[31]; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_320]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __v_404: G = __r_arr[0]; + let __v_405: G = __r_arr[1]; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_405, __v_404]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __v_406: G = __r_arr[0]; + let __v_407: G = __r_arr[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_22.as_canonical_u64() { _ => { let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; - let __v_360: G = __r_arr[0]; - let __v_361: G = G::from_bool((__v_360 == G::ZERO)); - let __v_362: G = G::from_u64(0); - if (__v_361 != __v_362) { - return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_362.as_canonical_u64(), msg: None }); + let __v_408: G = __r_arr[0]; + let __v_409: G = G::from_bool((__v_408 == G::ZERO)); + let __v_410: G = G::from_u64(0); + if (__v_409 != __v_410) { + return Err(ExecError::AssertEqMismatch { lhs: __v_409.as_canonical_u64(), rhs: __v_410.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_66]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; - let __v_363: G = __r_arr[0]; - if (__v_363 != __v_360) { - return Err(ExecError::AssertEqMismatch { lhs: __v_363.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); + let __v_411: G = __r_arr[0]; + if (__v_411 != __v_408) { + return Err(ExecError::AssertEqMismatch { lhs: __v_411.as_canonical_u64(), rhs: __v_408.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_68]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; - let __v_364: G = __r_arr[0]; - if (__v_364 != __v_360) { - return Err(ExecError::AssertEqMismatch { lhs: __v_364.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); + let __v_412: G = __r_arr[0]; + if (__v_412 != __v_408) { + return Err(ExecError::AssertEqMismatch { lhs: __v_412.as_canonical_u64(), rhs: __v_408.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_61]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; - let __v_365: G = __r_arr[0]; - if (__v_365 != __v_360) { - return Err(ExecError::AssertEqMismatch { lhs: __v_365.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); + let __v_413: G = __r_arr[0]; + if (__v_413 != __v_408) { + return Err(ExecError::AssertEqMismatch { lhs: __v_413.as_canonical_u64(), rhs: __v_408.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[160].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => aiur_fn_160(__args, record, io_buffer, __cu)? } }; - let __v_366: G = __r_arr[0]; - let __v_367: G = G::from_u64(1); - if (__v_366 != __v_367) { - return Err(ExecError::AssertEqMismatch { lhs: __v_366.as_canonical_u64(), rhs: __v_367.as_canonical_u64(), msg: None }); + let __v_414: G = __r_arr[0]; + let __v_415: G = G::from_u64(1); + if (__v_414 != __v_415) { + return Err(ExecError::AssertEqMismatch { lhs: __v_414.as_canonical_u64(), rhs: __v_415.as_canonical_u64(), msg: None }); } - let __v_368: G = G::from_u64(1); - break '__mc_0 [__v_368]; + let __v_416: G = G::from_u64(1); + break '__mc_0 [__v_416]; }, } }; - let __v_360: G = __mc_out___mc_0[0]; + let __v_408: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_159.as_canonical_u64() { _ => { match __v_159.as_canonical_u64() { @@ -25791,17 +26047,17 @@ fn aiur_fn_241( match __v_22.as_canonical_u64() { _ => { let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_256, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; - let __v_361: G = __r_arr[0]; + let __v_409: G = __r_arr[0]; let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_262, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_362: G = __r_arr[0]; + let __v_410: G = __r_arr[0]; match __v_24.as_canonical_u64() { _ => { let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_259.as_canonical_u64() { 0u64 => { - let __v_363: G = G::from_u64(1); - let __v_364: G = G::from_u64(1); - let __v_365: G = { let __values: [G; 3] = [__v_363, __v_364, __v_364]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - break '__mc_2 [__v_365]; + let __v_411: G = G::from_u64(1); + let __v_412: G = G::from_u64(1); + let __v_413: G = { let __values: [G; 3] = [__v_411, __v_412, __v_412]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + break '__mc_2 [__v_413]; }, 1u64 => { break '__mc_2 [__v_260]; @@ -25811,556 +26067,556 @@ fn aiur_fn_241( }, } }; - let __v_363: G = __mc_out___mc_2[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_34, __v_272]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; - let __v_364: G = __r_arr[0]; - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_24, __v_364]; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } }; - let __v_365: G = __r_arr[0]; - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_363, __v_365]; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } }; - let __v_366: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_22, __v_366]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; - let __v_367: G = __r_arr[0]; - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_266, __v_367]; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } }; - let __v_368: G = __r_arr[0]; - let __v_369: G = G::from_u64(0); - let __v_370: G = G::from_u64(109); - let __v_371: G = G::from_u64(0); - let __v_372: G = G::from_u64(117); - let __v_373: G = G::from_u64(0); - let __v_374: G = G::from_u64(108); - let __v_375: G = G::from_u64(0); - let __v_376: G = G::from_u64(116); - let __v_377: G = G::from_u64(0); - let __v_378: G = G::from_u64(105); - let __v_379: G = G::from_u64(0); - let __v_380: G = G::from_u64(45); - let __v_381: G = G::from_u64(0); - let __v_382: G = G::from_u64(115); - let __v_383: G = G::from_u64(0); - let __v_384: G = G::from_u64(116); - let __v_385: G = G::from_u64(0); - let __v_386: G = G::from_u64(97); - let __v_387: G = G::from_u64(0); - let __v_388: G = G::from_u64(114); - let __v_389: G = G::from_u64(0); - let __v_390: G = G::from_u64(107); - let __v_391: G = G::from_u64(0); - let __v_392: G = G::from_u64(47); - let __v_393: G = G::from_u64(0); - let __v_394: G = G::from_u64(118); - let __v_395: G = G::from_u64(0); - let __v_396: G = G::from_u64(48); - let __v_397: G = { let __values: [G; 3] = [__v_395, __v_396, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_398: G = { let __values: [G; 3] = [__v_393, __v_394, __v_397]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_399: G = { let __values: [G; 3] = [__v_391, __v_392, __v_398]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_400: G = { let __values: [G; 3] = [__v_389, __v_390, __v_399]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_401: G = { let __values: [G; 3] = [__v_387, __v_388, __v_400]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_402: G = { let __values: [G; 3] = [__v_385, __v_386, __v_401]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_403: G = { let __values: [G; 3] = [__v_383, __v_384, __v_402]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_404: G = { let __values: [G; 3] = [__v_381, __v_382, __v_403]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_405: G = { let __values: [G; 3] = [__v_379, __v_380, __v_404]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_406: G = { let __values: [G; 3] = [__v_377, __v_378, __v_405]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_407: G = { let __values: [G; 3] = [__v_375, __v_376, __v_406]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_408: G = { let __values: [G; 3] = [__v_373, __v_374, __v_407]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_409: G = { let __values: [G; 3] = [__v_371, __v_372, __v_408]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_410: G = { let __values: [G; 3] = [__v_369, __v_370, __v_409]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __v_411: G = G::from_u64(1); - let __v_412: G = G::from_u64(1); - let __v_413: G = { let __values: [G; 3] = [__v_411, __v_412, __v_412]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_410, __v_413]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __v_411: G = __mc_out___mc_2[0]; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_34, __v_320]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_412: G = __r_arr[0]; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_24, __v_412]; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __v_413: G = __r_arr[0]; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_411, __v_413]; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_414: G = __r_arr[0]; - let __v_415: G = __r_arr[1]; - let __v_416: G = __r_arr[2]; - let __v_417: G = __r_arr[3]; - let __v_418: G = __r_arr[4]; - let __v_419: G = __r_arr[5]; - let __v_420: G = __r_arr[6]; - let __v_421: G = __r_arr[7]; - let __v_422: G = __r_arr[8]; - let __v_423: G = __r_arr[9]; - let __v_424: G = __r_arr[10]; - let __v_425: G = __r_arr[11]; - let __v_426: G = __r_arr[12]; - let __v_427: G = __r_arr[13]; - let __v_428: G = __r_arr[14]; - let __v_429: G = __r_arr[15]; - let __v_430: G = __r_arr[16]; - let __v_431: G = __r_arr[17]; - let __v_432: G = G::from_u64(1); - let __v_433: G = G::from_u64(1); - let __v_434: G = { let __values: [G; 3] = [__v_432, __v_433, __v_433]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_434]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; - let __v_435: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_435]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; - let __v_436: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_430, __v_436]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; - let __v_437: G = __r_arr[0]; - let __v_438: G = G::from_u64(1); - let __v_439: G = G::from_u64(1); - let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_437, __v_440]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; - let __v_441: G = __r_arr[0]; - let __v_442: G = __r_arr[1]; - let __v_443: G = __r_arr[2]; - let __v_444: G = __r_arr[3]; - let __v_445: G = __r_arr[4]; - let __v_446: G = __r_arr[5]; - let __v_447: G = __r_arr[6]; - let __v_448: G = __r_arr[7]; - let __v_449: G = __r_arr[8]; - let __v_450: G = __r_arr[9]; - let __v_451: G = __r_arr[10]; - let __v_452: G = __r_arr[11]; - let __v_453: G = __r_arr[12]; - let __v_454: G = __r_arr[13]; - let __v_455: G = __r_arr[14]; - let __v_456: G = __r_arr[15]; - let __v_457: G = __r_arr[16]; - let __v_458: G = __r_arr[17]; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_22, __v_414]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_415: G = __r_arr[0]; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_314, __v_415]; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __v_416: G = __r_arr[0]; + let __v_417: G = G::from_u64(0); + let __v_418: G = G::from_u64(109); + let __v_419: G = G::from_u64(0); + let __v_420: G = G::from_u64(117); + let __v_421: G = G::from_u64(0); + let __v_422: G = G::from_u64(108); + let __v_423: G = G::from_u64(0); + let __v_424: G = G::from_u64(116); + let __v_425: G = G::from_u64(0); + let __v_426: G = G::from_u64(105); + let __v_427: G = G::from_u64(0); + let __v_428: G = G::from_u64(45); + let __v_429: G = G::from_u64(0); + let __v_430: G = G::from_u64(115); + let __v_431: G = G::from_u64(0); + let __v_432: G = G::from_u64(116); + let __v_433: G = G::from_u64(0); + let __v_434: G = G::from_u64(97); + let __v_435: G = G::from_u64(0); + let __v_436: G = G::from_u64(114); + let __v_437: G = G::from_u64(0); + let __v_438: G = G::from_u64(107); + let __v_439: G = G::from_u64(0); + let __v_440: G = G::from_u64(47); + let __v_441: G = G::from_u64(0); + let __v_442: G = G::from_u64(118); + let __v_443: G = G::from_u64(0); + let __v_444: G = G::from_u64(48); + let __v_445: G = { let __values: [G; 3] = [__v_443, __v_444, __v_416]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_446: G = { let __values: [G; 3] = [__v_441, __v_442, __v_445]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_447: G = { let __values: [G; 3] = [__v_439, __v_440, __v_446]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_448: G = { let __values: [G; 3] = [__v_437, __v_438, __v_447]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_449: G = { let __values: [G; 3] = [__v_435, __v_436, __v_448]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_450: G = { let __values: [G; 3] = [__v_433, __v_434, __v_449]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_451: G = { let __values: [G; 3] = [__v_431, __v_432, __v_450]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_452: G = { let __values: [G; 3] = [__v_429, __v_430, __v_451]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_453: G = { let __values: [G; 3] = [__v_427, __v_428, __v_452]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_454: G = { let __values: [G; 3] = [__v_425, __v_426, __v_453]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_455: G = { let __values: [G; 3] = [__v_423, __v_424, __v_454]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_456: G = { let __values: [G; 3] = [__v_421, __v_422, __v_455]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_457: G = { let __values: [G; 3] = [__v_419, __v_420, __v_456]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_458: G = { let __values: [G; 3] = [__v_417, __v_418, __v_457]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __v_459: G = G::from_u64(1); let __v_460: G = G::from_u64(1); let __v_461: G = { let __values: [G; 3] = [__v_459, __v_460, __v_460]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_449, __v_450, __v_451, __v_452, __v_453, __v_454, __v_455, __v_456, __v_461]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_458, __v_461]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_462: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_462]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; - let __v_463: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_457, __v_463]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; - let __v_464: G = __r_arr[0]; - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_464, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; - let __v_465: G = __r_arr[0]; - let __v_466: G = G::from_u64(1); - let __v_467: G = G::from_u64(1); - let __v_468: G = { let __values: [G; 3] = [__v_466, __v_467, __v_467]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_30, __v_468]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; - let __v_469: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_465, __v_469]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; - let __v_470: G = __r_arr[0]; - let __v_471: G = G::from_u64(1); - let __v_472: G = G::from_u64(1); - let __v_473: G = { let __values: [G; 3] = [__v_471, __v_472, __v_472]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_470, __v_473]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; - let __v_474: G = __r_arr[0]; - let __v_475: G = __r_arr[1]; - let __v_476: G = __r_arr[2]; - let __v_477: G = __r_arr[3]; - let __v_478: G = __r_arr[4]; - let __v_479: G = __r_arr[5]; - let __v_480: G = __r_arr[6]; - let __v_481: G = __r_arr[7]; - let __v_482: G = __r_arr[8]; - let __v_483: G = __r_arr[9]; - let __v_484: G = __r_arr[10]; - let __v_485: G = __r_arr[11]; - let __v_486: G = __r_arr[12]; - let __v_487: G = __r_arr[13]; - let __v_488: G = __r_arr[14]; - let __v_489: G = __r_arr[15]; - let __v_490: G = __r_arr[16]; - let __v_491: G = __r_arr[17]; - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_490, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; - let __v_492: G = __r_arr[0]; - let __v_493: G = G::from_u64(1); - let __v_494: G = G::from_u64(1); - let __v_495: G = { let __values: [G; 3] = [__v_493, __v_494, __v_494]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_492, __v_495]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; - let __v_496: G = __r_arr[0]; - let __v_497: G = __r_arr[1]; - let __v_498: G = __r_arr[2]; - let __v_499: G = __r_arr[3]; - let __v_500: G = __r_arr[4]; - let __v_501: G = __r_arr[5]; - let __v_502: G = __r_arr[6]; - let __v_503: G = __r_arr[7]; - let __v_504: G = __r_arr[8]; - let __v_505: G = __r_arr[9]; - let __v_506: G = __r_arr[10]; - let __v_507: G = __r_arr[11]; - let __v_508: G = __r_arr[12]; - let __v_509: G = __r_arr[13]; - let __v_510: G = __r_arr[14]; - let __v_511: G = __r_arr[15]; - let __v_512: G = __r_arr[16]; - let __v_513: G = __r_arr[17]; - let __v_514: G = G::from_u64(256); - let __v_515: G = (__v_514 * __v_415); - let __v_516: G = G::from_u64(65536); - let __v_517: G = (__v_516 * __v_416); - let __v_518: G = G::from_u64(16777216); - let __v_519: G = (__v_518 * __v_417); - let __v_520: G = G::from_u64(4294967296); - let __v_521: G = (__v_520 * __v_418); - let __v_522: G = G::from_u64(1099511627776); - let __v_523: G = (__v_522 * __v_419); - let __v_524: G = G::from_u64(281474976710656); - let __v_525: G = (__v_524 * __v_420); - let __v_526: G = G::from_u64(72057594037927936); - let __v_527: G = (__v_526 * __v_421); - let __v_528: G = (__v_525 + __v_527); - let __v_529: G = (__v_523 + __v_528); - let __v_530: G = (__v_521 + __v_529); - let __v_531: G = (__v_519 + __v_530); - let __v_532: G = (__v_517 + __v_531); - let __v_533: G = (__v_515 + __v_532); - let __v_534: G = (__v_414 + __v_533); - let __v_535: G = G::from_u64(256); - let __v_536: G = (__v_535 * __v_423); - let __v_537: G = G::from_u64(65536); - let __v_538: G = (__v_537 * __v_424); - let __v_539: G = G::from_u64(16777216); - let __v_540: G = (__v_539 * __v_425); - let __v_541: G = G::from_u64(4294967296); - let __v_542: G = (__v_541 * __v_426); - let __v_543: G = G::from_u64(1099511627776); - let __v_544: G = (__v_543 * __v_427); - let __v_545: G = G::from_u64(281474976710656); - let __v_546: G = (__v_545 * __v_428); - let __v_547: G = G::from_u64(72057594037927936); - let __v_548: G = (__v_547 * __v_429); - let __v_549: G = (__v_546 + __v_548); - let __v_550: G = (__v_544 + __v_549); - let __v_551: G = (__v_542 + __v_550); - let __v_552: G = (__v_540 + __v_551); - let __v_553: G = (__v_538 + __v_552); - let __v_554: G = (__v_536 + __v_553); - let __v_555: G = (__v_422 + __v_554); - let __v_556: G = G::from_u64(256); - let __v_557: G = (__v_556 * __v_442); - let __v_558: G = G::from_u64(65536); - let __v_559: G = (__v_558 * __v_443); - let __v_560: G = G::from_u64(16777216); - let __v_561: G = (__v_560 * __v_444); - let __v_562: G = G::from_u64(4294967296); - let __v_563: G = (__v_562 * __v_445); - let __v_564: G = G::from_u64(1099511627776); - let __v_565: G = (__v_564 * __v_446); - let __v_566: G = G::from_u64(281474976710656); - let __v_567: G = (__v_566 * __v_447); - let __v_568: G = G::from_u64(72057594037927936); - let __v_569: G = (__v_568 * __v_448); - let __v_570: G = (__v_567 + __v_569); - let __v_571: G = (__v_565 + __v_570); - let __v_572: G = (__v_563 + __v_571); - let __v_573: G = (__v_561 + __v_572); - let __v_574: G = (__v_559 + __v_573); - let __v_575: G = (__v_557 + __v_574); - let __v_576: G = (__v_441 + __v_575); - let __v_577: G = G::from_u64(256); - let __v_578: G = (__v_577 * __v_450); - let __v_579: G = G::from_u64(65536); - let __v_580: G = (__v_579 * __v_451); - let __v_581: G = G::from_u64(16777216); - let __v_582: G = (__v_581 * __v_452); - let __v_583: G = G::from_u64(4294967296); - let __v_584: G = (__v_583 * __v_453); - let __v_585: G = G::from_u64(1099511627776); - let __v_586: G = (__v_585 * __v_454); - let __v_587: G = G::from_u64(281474976710656); - let __v_588: G = (__v_587 * __v_455); - let __v_589: G = G::from_u64(72057594037927936); - let __v_590: G = (__v_589 * __v_456); - let __v_591: G = (__v_588 + __v_590); - let __v_592: G = (__v_586 + __v_591); - let __v_593: G = (__v_584 + __v_592); - let __v_594: G = (__v_582 + __v_593); - let __v_595: G = (__v_580 + __v_594); - let __v_596: G = (__v_578 + __v_595); - let __v_597: G = (__v_449 + __v_596); - let __v_598: G = G::from_u64(256); - let __v_599: G = (__v_598 * __v_475); - let __v_600: G = G::from_u64(65536); - let __v_601: G = (__v_600 * __v_476); - let __v_602: G = G::from_u64(16777216); - let __v_603: G = (__v_602 * __v_477); - let __v_604: G = G::from_u64(4294967296); - let __v_605: G = (__v_604 * __v_478); - let __v_606: G = G::from_u64(1099511627776); - let __v_607: G = (__v_606 * __v_479); - let __v_608: G = G::from_u64(281474976710656); - let __v_609: G = (__v_608 * __v_480); - let __v_610: G = G::from_u64(72057594037927936); - let __v_611: G = (__v_610 * __v_481); - let __v_612: G = (__v_609 + __v_611); - let __v_613: G = (__v_607 + __v_612); - let __v_614: G = (__v_605 + __v_613); - let __v_615: G = (__v_603 + __v_614); - let __v_616: G = (__v_601 + __v_615); - let __v_617: G = (__v_599 + __v_616); - let __v_618: G = (__v_474 + __v_617); - let __v_619: G = G::from_u64(256); - let __v_620: G = (__v_619 * __v_483); - let __v_621: G = G::from_u64(65536); - let __v_622: G = (__v_621 * __v_484); - let __v_623: G = G::from_u64(16777216); - let __v_624: G = (__v_623 * __v_485); - let __v_625: G = G::from_u64(4294967296); - let __v_626: G = (__v_625 * __v_486); - let __v_627: G = G::from_u64(1099511627776); - let __v_628: G = (__v_627 * __v_487); - let __v_629: G = G::from_u64(281474976710656); - let __v_630: G = (__v_629 * __v_488); - let __v_631: G = G::from_u64(72057594037927936); - let __v_632: G = (__v_631 * __v_489); - let __v_633: G = (__v_630 + __v_632); - let __v_634: G = (__v_628 + __v_633); - let __v_635: G = (__v_626 + __v_634); - let __v_636: G = (__v_624 + __v_635); - let __v_637: G = (__v_622 + __v_636); - let __v_638: G = (__v_620 + __v_637); - let __v_639: G = (__v_482 + __v_638); - let __v_640: G = G::from_u64(256); - let __v_641: G = (__v_640 * __v_497); - let __v_642: G = G::from_u64(65536); - let __v_643: G = (__v_642 * __v_498); - let __v_644: G = G::from_u64(16777216); - let __v_645: G = (__v_644 * __v_499); - let __v_646: G = G::from_u64(4294967296); - let __v_647: G = (__v_646 * __v_500); - let __v_648: G = G::from_u64(1099511627776); - let __v_649: G = (__v_648 * __v_501); - let __v_650: G = G::from_u64(281474976710656); - let __v_651: G = (__v_650 * __v_502); - let __v_652: G = G::from_u64(72057594037927936); - let __v_653: G = (__v_652 * __v_503); - let __v_654: G = (__v_651 + __v_653); - let __v_655: G = (__v_649 + __v_654); - let __v_656: G = (__v_647 + __v_655); - let __v_657: G = (__v_645 + __v_656); - let __v_658: G = (__v_643 + __v_657); - let __v_659: G = (__v_641 + __v_658); - let __v_660: G = (__v_496 + __v_659); - let __v_661: G = G::from_u64(256); - let __v_662: G = (__v_661 * __v_505); - let __v_663: G = G::from_u64(65536); - let __v_664: G = (__v_663 * __v_506); - let __v_665: G = G::from_u64(16777216); - let __v_666: G = (__v_665 * __v_507); - let __v_667: G = G::from_u64(4294967296); - let __v_668: G = (__v_667 * __v_508); - let __v_669: G = G::from_u64(1099511627776); - let __v_670: G = (__v_669 * __v_509); - let __v_671: G = G::from_u64(281474976710656); - let __v_672: G = (__v_671 * __v_510); - let __v_673: G = G::from_u64(72057594037927936); - let __v_674: G = (__v_673 * __v_511); - let __v_675: G = (__v_672 + __v_674); - let __v_676: G = (__v_670 + __v_675); - let __v_677: G = (__v_668 + __v_676); - let __v_678: G = (__v_666 + __v_677); - let __v_679: G = (__v_664 + __v_678); - let __v_680: G = (__v_662 + __v_679); - let __v_681: G = (__v_504 + __v_680); - let __v_682: G = G::from_u64(0); - let __v_683: G = G::from_u64(0); - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_682, __v_683, __v_358, __v_534, __v_555, __v_576, __v_597]; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } }; - let __v_684: G = __r_arr[0]; - let __v_685: G = __r_arr[1]; - let __v_686: G = G::from_u64(0); - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_361, __v_362, __v_34, __v_30, __v_66, __v_68, __v_63, __v_64, __v_61, __v_686, __v_684, __v_685, __v_534, __v_555, __v_576, __v_597, __v_618, __v_639, __v_660, __v_681]; let __cu = unconstrained; let __hit = record.function_queries[195].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => aiur_fn_195(__args, record, io_buffer, __cu)? } }; - let __v_687: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_361]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; - let __v_688: G = __r_arr[0]; + let __v_463: G = __r_arr[1]; + let __v_464: G = __r_arr[2]; + let __v_465: G = __r_arr[3]; + let __v_466: G = __r_arr[4]; + let __v_467: G = __r_arr[5]; + let __v_468: G = __r_arr[6]; + let __v_469: G = __r_arr[7]; + let __v_470: G = __r_arr[8]; + let __v_471: G = __r_arr[9]; + let __v_472: G = __r_arr[10]; + let __v_473: G = __r_arr[11]; + let __v_474: G = __r_arr[12]; + let __v_475: G = __r_arr[13]; + let __v_476: G = __r_arr[14]; + let __v_477: G = __r_arr[15]; + let __v_478: G = __r_arr[16]; + let __v_479: G = __r_arr[17]; + let __v_480: G = G::from_u64(1); + let __v_481: G = G::from_u64(1); + let __v_482: G = { let __values: [G; 3] = [__v_480, __v_481, __v_481]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_470, __v_471, __v_472, __v_473, __v_474, __v_475, __v_476, __v_477, __v_482]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __v_483: G = __r_arr[0]; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_462, __v_463, __v_464, __v_465, __v_466, __v_467, __v_468, __v_469, __v_483]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __v_484: G = __r_arr[0]; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_478, __v_484]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_485: G = __r_arr[0]; + let __v_486: G = G::from_u64(1); + let __v_487: G = G::from_u64(1); + let __v_488: G = { let __values: [G; 3] = [__v_486, __v_487, __v_487]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_485, __v_488]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __v_489: G = __r_arr[0]; + let __v_490: G = __r_arr[1]; + let __v_491: G = __r_arr[2]; + let __v_492: G = __r_arr[3]; + let __v_493: G = __r_arr[4]; + let __v_494: G = __r_arr[5]; + let __v_495: G = __r_arr[6]; + let __v_496: G = __r_arr[7]; + let __v_497: G = __r_arr[8]; + let __v_498: G = __r_arr[9]; + let __v_499: G = __r_arr[10]; + let __v_500: G = __r_arr[11]; + let __v_501: G = __r_arr[12]; + let __v_502: G = __r_arr[13]; + let __v_503: G = __r_arr[14]; + let __v_504: G = __r_arr[15]; + let __v_505: G = __r_arr[16]; + let __v_506: G = __r_arr[17]; + let __v_507: G = G::from_u64(1); + let __v_508: G = G::from_u64(1); + let __v_509: G = { let __values: [G; 3] = [__v_507, __v_508, __v_508]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_497, __v_498, __v_499, __v_500, __v_501, __v_502, __v_503, __v_504, __v_509]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __v_510: G = __r_arr[0]; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_489, __v_490, __v_491, __v_492, __v_493, __v_494, __v_495, __v_496, __v_510]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __v_511: G = __r_arr[0]; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_505, __v_511]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_512: G = __r_arr[0]; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_512, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __v_513: G = __r_arr[0]; + let __v_514: G = G::from_u64(1); + let __v_515: G = G::from_u64(1); + let __v_516: G = { let __values: [G; 3] = [__v_514, __v_515, __v_515]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_30, __v_516]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __v_517: G = __r_arr[0]; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_513, __v_517]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_518: G = __r_arr[0]; + let __v_519: G = G::from_u64(1); + let __v_520: G = G::from_u64(1); + let __v_521: G = { let __values: [G; 3] = [__v_519, __v_520, __v_520]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_518, __v_521]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __v_522: G = __r_arr[0]; + let __v_523: G = __r_arr[1]; + let __v_524: G = __r_arr[2]; + let __v_525: G = __r_arr[3]; + let __v_526: G = __r_arr[4]; + let __v_527: G = __r_arr[5]; + let __v_528: G = __r_arr[6]; + let __v_529: G = __r_arr[7]; + let __v_530: G = __r_arr[8]; + let __v_531: G = __r_arr[9]; + let __v_532: G = __r_arr[10]; + let __v_533: G = __r_arr[11]; + let __v_534: G = __r_arr[12]; + let __v_535: G = __r_arr[13]; + let __v_536: G = __r_arr[14]; + let __v_537: G = __r_arr[15]; + let __v_538: G = __r_arr[16]; + let __v_539: G = __r_arr[17]; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_538, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __v_540: G = __r_arr[0]; + let __v_541: G = G::from_u64(1); + let __v_542: G = G::from_u64(1); + let __v_543: G = { let __values: [G; 3] = [__v_541, __v_542, __v_542]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_540, __v_543]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __v_544: G = __r_arr[0]; + let __v_545: G = __r_arr[1]; + let __v_546: G = __r_arr[2]; + let __v_547: G = __r_arr[3]; + let __v_548: G = __r_arr[4]; + let __v_549: G = __r_arr[5]; + let __v_550: G = __r_arr[6]; + let __v_551: G = __r_arr[7]; + let __v_552: G = __r_arr[8]; + let __v_553: G = __r_arr[9]; + let __v_554: G = __r_arr[10]; + let __v_555: G = __r_arr[11]; + let __v_556: G = __r_arr[12]; + let __v_557: G = __r_arr[13]; + let __v_558: G = __r_arr[14]; + let __v_559: G = __r_arr[15]; + let __v_560: G = __r_arr[16]; + let __v_561: G = __r_arr[17]; + let __v_562: G = G::from_u64(256); + let __v_563: G = (__v_562 * __v_463); + let __v_564: G = G::from_u64(65536); + let __v_565: G = (__v_564 * __v_464); + let __v_566: G = G::from_u64(16777216); + let __v_567: G = (__v_566 * __v_465); + let __v_568: G = G::from_u64(4294967296); + let __v_569: G = (__v_568 * __v_466); + let __v_570: G = G::from_u64(1099511627776); + let __v_571: G = (__v_570 * __v_467); + let __v_572: G = G::from_u64(281474976710656); + let __v_573: G = (__v_572 * __v_468); + let __v_574: G = G::from_u64(72057594037927936); + let __v_575: G = (__v_574 * __v_469); + let __v_576: G = (__v_573 + __v_575); + let __v_577: G = (__v_571 + __v_576); + let __v_578: G = (__v_569 + __v_577); + let __v_579: G = (__v_567 + __v_578); + let __v_580: G = (__v_565 + __v_579); + let __v_581: G = (__v_563 + __v_580); + let __v_582: G = (__v_462 + __v_581); + let __v_583: G = G::from_u64(256); + let __v_584: G = (__v_583 * __v_471); + let __v_585: G = G::from_u64(65536); + let __v_586: G = (__v_585 * __v_472); + let __v_587: G = G::from_u64(16777216); + let __v_588: G = (__v_587 * __v_473); + let __v_589: G = G::from_u64(4294967296); + let __v_590: G = (__v_589 * __v_474); + let __v_591: G = G::from_u64(1099511627776); + let __v_592: G = (__v_591 * __v_475); + let __v_593: G = G::from_u64(281474976710656); + let __v_594: G = (__v_593 * __v_476); + let __v_595: G = G::from_u64(72057594037927936); + let __v_596: G = (__v_595 * __v_477); + let __v_597: G = (__v_594 + __v_596); + let __v_598: G = (__v_592 + __v_597); + let __v_599: G = (__v_590 + __v_598); + let __v_600: G = (__v_588 + __v_599); + let __v_601: G = (__v_586 + __v_600); + let __v_602: G = (__v_584 + __v_601); + let __v_603: G = (__v_470 + __v_602); + let __v_604: G = G::from_u64(256); + let __v_605: G = (__v_604 * __v_490); + let __v_606: G = G::from_u64(65536); + let __v_607: G = (__v_606 * __v_491); + let __v_608: G = G::from_u64(16777216); + let __v_609: G = (__v_608 * __v_492); + let __v_610: G = G::from_u64(4294967296); + let __v_611: G = (__v_610 * __v_493); + let __v_612: G = G::from_u64(1099511627776); + let __v_613: G = (__v_612 * __v_494); + let __v_614: G = G::from_u64(281474976710656); + let __v_615: G = (__v_614 * __v_495); + let __v_616: G = G::from_u64(72057594037927936); + let __v_617: G = (__v_616 * __v_496); + let __v_618: G = (__v_615 + __v_617); + let __v_619: G = (__v_613 + __v_618); + let __v_620: G = (__v_611 + __v_619); + let __v_621: G = (__v_609 + __v_620); + let __v_622: G = (__v_607 + __v_621); + let __v_623: G = (__v_605 + __v_622); + let __v_624: G = (__v_489 + __v_623); + let __v_625: G = G::from_u64(256); + let __v_626: G = (__v_625 * __v_498); + let __v_627: G = G::from_u64(65536); + let __v_628: G = (__v_627 * __v_499); + let __v_629: G = G::from_u64(16777216); + let __v_630: G = (__v_629 * __v_500); + let __v_631: G = G::from_u64(4294967296); + let __v_632: G = (__v_631 * __v_501); + let __v_633: G = G::from_u64(1099511627776); + let __v_634: G = (__v_633 * __v_502); + let __v_635: G = G::from_u64(281474976710656); + let __v_636: G = (__v_635 * __v_503); + let __v_637: G = G::from_u64(72057594037927936); + let __v_638: G = (__v_637 * __v_504); + let __v_639: G = (__v_636 + __v_638); + let __v_640: G = (__v_634 + __v_639); + let __v_641: G = (__v_632 + __v_640); + let __v_642: G = (__v_630 + __v_641); + let __v_643: G = (__v_628 + __v_642); + let __v_644: G = (__v_626 + __v_643); + let __v_645: G = (__v_497 + __v_644); + let __v_646: G = G::from_u64(256); + let __v_647: G = (__v_646 * __v_523); + let __v_648: G = G::from_u64(65536); + let __v_649: G = (__v_648 * __v_524); + let __v_650: G = G::from_u64(16777216); + let __v_651: G = (__v_650 * __v_525); + let __v_652: G = G::from_u64(4294967296); + let __v_653: G = (__v_652 * __v_526); + let __v_654: G = G::from_u64(1099511627776); + let __v_655: G = (__v_654 * __v_527); + let __v_656: G = G::from_u64(281474976710656); + let __v_657: G = (__v_656 * __v_528); + let __v_658: G = G::from_u64(72057594037927936); + let __v_659: G = (__v_658 * __v_529); + let __v_660: G = (__v_657 + __v_659); + let __v_661: G = (__v_655 + __v_660); + let __v_662: G = (__v_653 + __v_661); + let __v_663: G = (__v_651 + __v_662); + let __v_664: G = (__v_649 + __v_663); + let __v_665: G = (__v_647 + __v_664); + let __v_666: G = (__v_522 + __v_665); + let __v_667: G = G::from_u64(256); + let __v_668: G = (__v_667 * __v_531); + let __v_669: G = G::from_u64(65536); + let __v_670: G = (__v_669 * __v_532); + let __v_671: G = G::from_u64(16777216); + let __v_672: G = (__v_671 * __v_533); + let __v_673: G = G::from_u64(4294967296); + let __v_674: G = (__v_673 * __v_534); + let __v_675: G = G::from_u64(1099511627776); + let __v_676: G = (__v_675 * __v_535); + let __v_677: G = G::from_u64(281474976710656); + let __v_678: G = (__v_677 * __v_536); + let __v_679: G = G::from_u64(72057594037927936); + let __v_680: G = (__v_679 * __v_537); + let __v_681: G = (__v_678 + __v_680); + let __v_682: G = (__v_676 + __v_681); + let __v_683: G = (__v_674 + __v_682); + let __v_684: G = (__v_672 + __v_683); + let __v_685: G = (__v_670 + __v_684); + let __v_686: G = (__v_668 + __v_685); + let __v_687: G = (__v_530 + __v_686); + let __v_688: G = G::from_u64(256); + let __v_689: G = (__v_688 * __v_545); + let __v_690: G = G::from_u64(65536); + let __v_691: G = (__v_690 * __v_546); + let __v_692: G = G::from_u64(16777216); + let __v_693: G = (__v_692 * __v_547); + let __v_694: G = G::from_u64(4294967296); + let __v_695: G = (__v_694 * __v_548); + let __v_696: G = G::from_u64(1099511627776); + let __v_697: G = (__v_696 * __v_549); + let __v_698: G = G::from_u64(281474976710656); + let __v_699: G = (__v_698 * __v_550); + let __v_700: G = G::from_u64(72057594037927936); + let __v_701: G = (__v_700 * __v_551); + let __v_702: G = (__v_699 + __v_701); + let __v_703: G = (__v_697 + __v_702); + let __v_704: G = (__v_695 + __v_703); + let __v_705: G = (__v_693 + __v_704); + let __v_706: G = (__v_691 + __v_705); + let __v_707: G = (__v_689 + __v_706); + let __v_708: G = (__v_544 + __v_707); + let __v_709: G = G::from_u64(256); + let __v_710: G = (__v_709 * __v_553); + let __v_711: G = G::from_u64(65536); + let __v_712: G = (__v_711 * __v_554); + let __v_713: G = G::from_u64(16777216); + let __v_714: G = (__v_713 * __v_555); + let __v_715: G = G::from_u64(4294967296); + let __v_716: G = (__v_715 * __v_556); + let __v_717: G = G::from_u64(1099511627776); + let __v_718: G = (__v_717 * __v_557); + let __v_719: G = G::from_u64(281474976710656); + let __v_720: G = (__v_719 * __v_558); + let __v_721: G = G::from_u64(72057594037927936); + let __v_722: G = (__v_721 * __v_559); + let __v_723: G = (__v_720 + __v_722); + let __v_724: G = (__v_718 + __v_723); + let __v_725: G = (__v_716 + __v_724); + let __v_726: G = (__v_714 + __v_725); + let __v_727: G = (__v_712 + __v_726); + let __v_728: G = (__v_710 + __v_727); + let __v_729: G = (__v_552 + __v_728); + let __v_730: G = G::from_u64(0); + let __v_731: G = G::from_u64(0); + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_730, __v_731, __v_406, __v_582, __v_603, __v_624, __v_645]; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __v_732: G = __r_arr[0]; + let __v_733: G = __r_arr[1]; + let __v_734: G = G::from_u64(0); + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_409, __v_410, __v_34, __v_30, __v_66, __v_68, __v_63, __v_64, __v_61, __v_734, __v_732, __v_733, __v_582, __v_603, __v_624, __v_645, __v_666, __v_687, __v_708, __v_729]; let __cu = unconstrained; let __hit = record.function_queries[195].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __v_735: G = __r_arr[0]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_409]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_736: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; - let __v_689: G = __r_arr[0]; - let __v_690: G = G::from_u64(1); - let __v_691: G = G::from_u64(1); - let __v_692: G = { let __values: [G; 3] = [__v_690, __v_691, __v_691]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __v_737: G = __r_arr[0]; + let __v_738: G = G::from_u64(1); + let __v_739: G = G::from_u64(1); + let __v_740: G = { let __values: [G; 3] = [__v_738, __v_739, __v_739]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_63.as_canonical_u64() { 0u64 => { - break '__mc_3 [__v_692]; + break '__mc_3 [__v_740]; }, 1u64 => { - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_64, __v_692]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; - let __v_693: G = __r_arr[0]; - break '__mc_3 [__v_693]; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_64, __v_740]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __v_741: G = __r_arr[0]; + break '__mc_3 [__v_741]; }, _ => { return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64())); }, } }; - let __v_693: G = __mc_out___mc_3[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_61, __v_693]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; - let __v_694: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_68, __v_694]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; - let __v_695: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_66, __v_695]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; - let __v_696: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_512, __v_696]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; - let __v_697: G = __r_arr[0]; - let __v_698: G = G::from_u64(1); - let __v_699: G = G::from_u64(1); - let __v_700: G = { let __values: [G; 3] = [__v_698, __v_699, __v_699]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_697, __v_700]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; - let __v_701: G = __r_arr[0]; - let __v_702: G = __r_arr[1]; - let __v_703: G = __r_arr[2]; - let __v_704: G = __r_arr[3]; - let __v_705: G = __r_arr[4]; - let __v_706: G = __r_arr[5]; - let __v_707: G = __r_arr[6]; - let __v_708: G = __r_arr[7]; - let __v_709: G = __r_arr[8]; - let __v_710: G = __r_arr[9]; - let __v_711: G = __r_arr[10]; - let __v_712: G = __r_arr[11]; - let __v_713: G = __r_arr[12]; - let __v_714: G = __r_arr[13]; - let __v_715: G = __r_arr[14]; - let __v_716: G = __r_arr[15]; - let __v_717: G = __r_arr[16]; - let __v_718: G = __r_arr[17]; - let __v_719: G = G::from_u64(256); - let __v_720: G = (__v_719 * __v_702); - let __v_721: G = G::from_u64(65536); - let __v_722: G = (__v_721 * __v_703); - let __v_723: G = G::from_u64(16777216); - let __v_724: G = (__v_723 * __v_704); - let __v_725: G = G::from_u64(4294967296); - let __v_726: G = (__v_725 * __v_705); - let __v_727: G = G::from_u64(1099511627776); - let __v_728: G = (__v_727 * __v_706); - let __v_729: G = G::from_u64(281474976710656); - let __v_730: G = (__v_729 * __v_707); - let __v_731: G = G::from_u64(72057594037927936); - let __v_732: G = (__v_731 * __v_708); - let __v_733: G = (__v_730 + __v_732); - let __v_734: G = (__v_728 + __v_733); - let __v_735: G = (__v_726 + __v_734); - let __v_736: G = (__v_724 + __v_735); - let __v_737: G = (__v_722 + __v_736); - let __v_738: G = (__v_720 + __v_737); - let __v_739: G = (__v_701 + __v_738); - let __v_740: G = G::from_u64(256); - let __v_741: G = (__v_740 * __v_710); - let __v_742: G = G::from_u64(65536); - let __v_743: G = (__v_742 * __v_711); - let __v_744: G = G::from_u64(16777216); - let __v_745: G = (__v_744 * __v_712); - let __v_746: G = G::from_u64(4294967296); - let __v_747: G = (__v_746 * __v_713); - let __v_748: G = G::from_u64(1099511627776); - let __v_749: G = (__v_748 * __v_714); - let __v_750: G = G::from_u64(281474976710656); - let __v_751: G = (__v_750 * __v_715); - let __v_752: G = G::from_u64(72057594037927936); - let __v_753: G = (__v_752 * __v_716); - let __v_754: G = (__v_751 + __v_753); - let __v_755: G = (__v_749 + __v_754); - let __v_756: G = (__v_747 + __v_755); - let __v_757: G = (__v_745 + __v_756); - let __v_758: G = (__v_743 + __v_757); - let __v_759: G = (__v_741 + __v_758); - let __v_760: G = (__v_709 + __v_759); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_717, __v_38, __v_40, __v_209]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; - let __v_761: G = __r_arr[0]; - let __v_762: G = __r_arr[1]; - let __v_763: G = G::from_u64(1); - let __v_764: G = G::from_u64(1); - let __v_765: G = { let __values: [G; 3] = [__v_763, __v_764, __v_764]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_50, __v_765]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; - let __v_766: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_762, __v_766]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; - let __v_767: G = __r_arr[0]; - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_767, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; - let __v_768: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_768, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_219]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; - let __v_769: G = __r_arr[0]; - let __v_770: G = __r_arr[1]; - let __v_771: G = (__v_689 + __v_159); - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_769, __v_770, __v_199, __v_771]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; - let __v_772: G = __r_arr[0]; - let __v_773: G = G::from_u64(0); - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_44, __v_48, __v_773, __v_199]; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } }; - let __v_774: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_769, __v_770, __v_774, __v_739, __v_760, __v_66, __v_68, __v_61, __v_63, __v_64, __v_24, __v_26, __v_28, __v_363, __v_362, __v_34, __v_660, __v_681, __v_688, __v_159, __v_771, __v_761, __v_38, __v_50, __v_689]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; - let __v_775: G = __r_arr[0]; - let __v_776: G = G::from_u64(0); - if (__v_169 != __v_776) { - return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_776.as_canonical_u64(), msg: None }); + let __v_741: G = __mc_out___mc_3[0]; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_61, __v_741]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __v_742: G = __r_arr[0]; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_68, __v_742]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __v_743: G = __r_arr[0]; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_66, __v_743]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __v_744: G = __r_arr[0]; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_560, __v_744]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_745: G = __r_arr[0]; + let __v_746: G = G::from_u64(1); + let __v_747: G = G::from_u64(1); + let __v_748: G = { let __values: [G; 3] = [__v_746, __v_747, __v_747]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_745, __v_748]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __v_749: G = __r_arr[0]; + let __v_750: G = __r_arr[1]; + let __v_751: G = __r_arr[2]; + let __v_752: G = __r_arr[3]; + let __v_753: G = __r_arr[4]; + let __v_754: G = __r_arr[5]; + let __v_755: G = __r_arr[6]; + let __v_756: G = __r_arr[7]; + let __v_757: G = __r_arr[8]; + let __v_758: G = __r_arr[9]; + let __v_759: G = __r_arr[10]; + let __v_760: G = __r_arr[11]; + let __v_761: G = __r_arr[12]; + let __v_762: G = __r_arr[13]; + let __v_763: G = __r_arr[14]; + let __v_764: G = __r_arr[15]; + let __v_765: G = __r_arr[16]; + let __v_766: G = __r_arr[17]; + let __v_767: G = G::from_u64(256); + let __v_768: G = (__v_767 * __v_750); + let __v_769: G = G::from_u64(65536); + let __v_770: G = (__v_769 * __v_751); + let __v_771: G = G::from_u64(16777216); + let __v_772: G = (__v_771 * __v_752); + let __v_773: G = G::from_u64(4294967296); + let __v_774: G = (__v_773 * __v_753); + let __v_775: G = G::from_u64(1099511627776); + let __v_776: G = (__v_775 * __v_754); + let __v_777: G = G::from_u64(281474976710656); + let __v_778: G = (__v_777 * __v_755); + let __v_779: G = G::from_u64(72057594037927936); + let __v_780: G = (__v_779 * __v_756); + let __v_781: G = (__v_778 + __v_780); + let __v_782: G = (__v_776 + __v_781); + let __v_783: G = (__v_774 + __v_782); + let __v_784: G = (__v_772 + __v_783); + let __v_785: G = (__v_770 + __v_784); + let __v_786: G = (__v_768 + __v_785); + let __v_787: G = (__v_749 + __v_786); + let __v_788: G = G::from_u64(256); + let __v_789: G = (__v_788 * __v_758); + let __v_790: G = G::from_u64(65536); + let __v_791: G = (__v_790 * __v_759); + let __v_792: G = G::from_u64(16777216); + let __v_793: G = (__v_792 * __v_760); + let __v_794: G = G::from_u64(4294967296); + let __v_795: G = (__v_794 * __v_761); + let __v_796: G = G::from_u64(1099511627776); + let __v_797: G = (__v_796 * __v_762); + let __v_798: G = G::from_u64(281474976710656); + let __v_799: G = (__v_798 * __v_763); + let __v_800: G = G::from_u64(72057594037927936); + let __v_801: G = (__v_800 * __v_764); + let __v_802: G = (__v_799 + __v_801); + let __v_803: G = (__v_797 + __v_802); + let __v_804: G = (__v_795 + __v_803); + let __v_805: G = (__v_793 + __v_804); + let __v_806: G = (__v_791 + __v_805); + let __v_807: G = (__v_789 + __v_806); + let __v_808: G = (__v_757 + __v_807); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_765, __v_38, __v_40, __v_209]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_809: G = __r_arr[0]; + let __v_810: G = __r_arr[1]; + let __v_811: G = G::from_u64(1); + let __v_812: G = G::from_u64(1); + let __v_813: G = { let __values: [G; 3] = [__v_811, __v_812, __v_812]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_50, __v_813]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __v_814: G = __r_arr[0]; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_810, __v_814]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_815: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_815, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_816: G = __r_arr[0]; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_816, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_219]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __v_817: G = __r_arr[0]; + let __v_818: G = __r_arr[1]; + let __v_819: G = (__v_737 + __v_159); + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_817, __v_818, __v_199, __v_819]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_820: G = __r_arr[0]; + let __v_821: G = G::from_u64(0); + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_44, __v_48, __v_821, __v_199]; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __v_822: G = __r_arr[0]; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_817, __v_818, __v_822, __v_787, __v_808, __v_66, __v_68, __v_61, __v_63, __v_64, __v_24, __v_26, __v_28, __v_411, __v_410, __v_34, __v_708, __v_729, __v_736, __v_159, __v_819, __v_809, __v_38, __v_50, __v_737]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_823: G = __r_arr[0]; + let __v_824: G = G::from_u64(0); + if (__v_169 != __v_824) { + return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_824.as_canonical_u64(), msg: None }); } - let __v_777: G = G::from_u64(0); - if (__v_179 != __v_777) { - return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_777.as_canonical_u64(), msg: None }); + let __v_825: G = G::from_u64(0); + if (__v_179 != __v_825) { + return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_825.as_canonical_u64(), msg: None }); } - let __v_778: G = G::from_u64(1); - if (__v_189 != __v_778) { - return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_778.as_canonical_u64(), msg: None }); + let __v_826: G = G::from_u64(1); + if (__v_189 != __v_826) { + return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_826.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } }; - let __v_779: G = __r_arr[0]; - let __v_780: G = G::from_u64(1); - if (__v_779 != __v_780) { - return Err(ExecError::AssertEqMismatch { lhs: __v_779.as_canonical_u64(), rhs: __v_780.as_canonical_u64(), msg: None }); + let __v_827: G = __r_arr[0]; + let __v_828: G = G::from_u64(1); + if (__v_827 != __v_828) { + return Err(ExecError::AssertEqMismatch { lhs: __v_827.as_canonical_u64(), rhs: __v_828.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; - let __v_781: G = __r_arr[0]; + let __v_829: G = __r_arr[0]; let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_256]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; - let __v_782: G = __r_arr[0]; - let __v_783: G = (__v_781 - __v_782); - let __v_784: G = G::from_bool((__v_783 == G::ZERO)); - let __v_785: G = G::from_u64(1); - if (__v_784 != __v_785) { - return Err(ExecError::AssertEqMismatch { lhs: __v_784.as_canonical_u64(), rhs: __v_785.as_canonical_u64(), msg: None }); + let __v_830: G = __r_arr[0]; + let __v_831: G = (__v_829 - __v_830); + let __v_832: G = G::from_bool((__v_831 == G::ZERO)); + let __v_833: G = G::from_u64(1); + if (__v_832 != __v_833) { + return Err(ExecError::AssertEqMismatch { lhs: __v_832.as_canonical_u64(), rhs: __v_833.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_361]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; - let __v_786: G = __r_arr[0]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_409]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_834: G = __r_arr[0]; let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; - let __v_787: G = __r_arr[0]; - let __v_788: G = (__v_786 - __v_787); - let __v_789: G = G::from_bool((__v_788 == G::ZERO)); - let __v_790: G = G::from_u64(1); - if (__v_789 != __v_790) { - return Err(ExecError::AssertEqMismatch { lhs: __v_789.as_canonical_u64(), rhs: __v_790.as_canonical_u64(), msg: None }); + let __v_835: G = __r_arr[0]; + let __v_836: G = (__v_834 - __v_835); + let __v_837: G = G::from_bool((__v_836 == G::ZERO)); + let __v_838: G = G::from_u64(1); + if (__v_837 != __v_838) { + return Err(ExecError::AssertEqMismatch { lhs: __v_837.as_canonical_u64(), rhs: __v_838.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } }; - let __v_791: G = __r_arr[0]; - let __v_792: G = (__v_791 - __v_689); - let __v_793: G = G::from_bool((__v_792 == G::ZERO)); - let __v_794: G = G::from_u64(1); - if (__v_793 != __v_794) { - return Err(ExecError::AssertEqMismatch { lhs: __v_793.as_canonical_u64(), rhs: __v_794.as_canonical_u64(), msg: None }); + let __v_839: G = __r_arr[0]; + let __v_840: G = (__v_839 - __v_737); + let __v_841: G = G::from_bool((__v_840 == G::ZERO)); + let __v_842: G = G::from_u64(1); + if (__v_841 != __v_842) { + return Err(ExecError::AssertEqMismatch { lhs: __v_841.as_canonical_u64(), rhs: __v_842.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; - let __v_795: G = __r_arr[0]; - let __v_796: G = G::from_u64(3); + let __v_843: G = __r_arr[0]; + let __v_844: G = G::from_u64(3); let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_63, __v_64]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; - let __v_797: G = __r_arr[0]; - let __v_798: G = (__v_796 + __v_797); - if (__v_795 != __v_798) { - return Err(ExecError::AssertEqMismatch { lhs: __v_795.as_canonical_u64(), rhs: __v_798.as_canonical_u64(), msg: None }); + let __v_845: G = __r_arr[0]; + let __v_846: G = (__v_844 + __v_845); + if (__v_843 != __v_846) { + return Err(ExecError::AssertEqMismatch { lhs: __v_843.as_canonical_u64(), rhs: __v_846.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; - let __v_799: G = __r_arr[0]; - let __v_800: G = (__v_799 - __v_689); - let __v_801: G = G::from_bool((__v_800 == G::ZERO)); - let __v_802: G = G::from_u64(1); - if (__v_801 != __v_802) { - return Err(ExecError::AssertEqMismatch { lhs: __v_801.as_canonical_u64(), rhs: __v_802.as_canonical_u64(), msg: None }); + let __v_847: G = __r_arr[0]; + let __v_848: G = (__v_847 - __v_737); + let __v_849: G = G::from_bool((__v_848 == G::ZERO)); + let __v_850: G = G::from_u64(1); + if (__v_849 != __v_850) { + return Err(ExecError::AssertEqMismatch { lhs: __v_849.as_canonical_u64(), rhs: __v_850.as_canonical_u64(), msg: None }); } let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; - let __v_803: G = __r_arr[0]; - let __v_804: G = G::from_u64(1); - if (__v_803 != __v_804) { - return Err(ExecError::AssertEqMismatch { lhs: __v_803.as_canonical_u64(), rhs: __v_804.as_canonical_u64(), msg: None }); + let __v_851: G = __r_arr[0]; + let __v_852: G = G::from_u64(1); + if (__v_851 != __v_852) { + return Err(ExecError::AssertEqMismatch { lhs: __v_851.as_canonical_u64(), rhs: __v_852.as_canonical_u64(), msg: None }); } - let __v_805: G = G::from_u64(33); - let __v_806: G = { let __a_val = __v_771.as_canonical_u64(); let __b_val = __v_805.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_807: G = G::from_u64(1); - if (__v_806 != __v_807) { - return Err(ExecError::AssertEqMismatch { lhs: __v_806.as_canonical_u64(), rhs: __v_807.as_canonical_u64(), msg: None }); + let __v_853: G = G::from_u64(33); + let __v_854: G = { let __a_val = __v_819.as_canonical_u64(); let __b_val = __v_853.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_855: G = G::from_u64(1); + if (__v_854 != __v_855) { + return Err(ExecError::AssertEqMismatch { lhs: __v_854.as_canonical_u64(), rhs: __v_855.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_44, __v_772, __v_24, __v_26, __v_28, __v_363, __v_63, __v_64, __v_362, __v_34, __v_688, __v_159, __v_771]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; - let __v_808: G = __r_arr[0]; - let __v_809: G = G::from_u64(1); - if (__v_808 != __v_809) { - return Err(ExecError::AssertEqMismatch { lhs: __v_808.as_canonical_u64(), rhs: __v_809.as_canonical_u64(), msg: None }); + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_44, __v_820, __v_24, __v_26, __v_28, __v_411, __v_63, __v_64, __v_410, __v_34, __v_736, __v_159, __v_819]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __v_856: G = __r_arr[0]; + let __v_857: G = G::from_u64(1); + if (__v_856 != __v_857) { + return Err(ExecError::AssertEqMismatch { lhs: __v_856.as_canonical_u64(), rhs: __v_857.as_canonical_u64(), msg: None }); } - let __v_810: G = G::from_u64(0); - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_48, __v_38, __v_775, __v_772, __v_810, __v_771]; let __cu = unconstrained; let __hit = record.function_queries[157].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => aiur_fn_157(__args, record, io_buffer, __cu)? } }; - let __v_811: G = __r_arr[0]; - break '__mc_1 [__v_811]; + let __v_858: G = G::from_u64(0); + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_48, __v_38, __v_823, __v_820, __v_858, __v_819]; let __cu = unconstrained; let __hit = record.function_queries[157].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __v_859: G = __r_arr[0]; + break '__mc_1 [__v_859]; }, } }, @@ -26372,240 +26628,240 @@ fn aiur_fn_241( }, } }; - let __v_361: G = __mc_out___mc_1[0]; - let __v_362: G = (__v_18 + __v_19); - if (__v_69 != __v_362) { - return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_362.as_canonical_u64(), msg: None }); - } - let __v_363: G = G::from_u64(256); - let __v_364: G = (__v_363 * __v_128); - let __v_365: G = G::from_u64(65536); - let __v_366: G = (__v_365 * __v_129); - let __v_367: G = G::from_u64(16777216); - let __v_368: G = (__v_367 * __v_130); - let __v_369: G = (__v_366 + __v_368); - let __v_370: G = (__v_364 + __v_369); - let __v_371: G = (__v_127 + __v_370); - let __v_372: G = G::from_u64(256); - let __v_373: G = (__v_372 * __v_132); - let __v_374: G = G::from_u64(65536); - let __v_375: G = (__v_374 * __v_133); - let __v_376: G = G::from_u64(16777216); - let __v_377: G = (__v_376 * __v_134); - let __v_378: G = (__v_375 + __v_377); - let __v_379: G = (__v_373 + __v_378); - let __v_380: G = (__v_131 + __v_379); - let __v_381: G = G::from_u64(256); - let __v_382: G = (__v_381 * __v_136); - let __v_383: G = G::from_u64(65536); - let __v_384: G = (__v_383 * __v_137); - let __v_385: G = G::from_u64(16777216); - let __v_386: G = (__v_385 * __v_138); - let __v_387: G = (__v_384 + __v_386); - let __v_388: G = (__v_382 + __v_387); - let __v_389: G = (__v_135 + __v_388); - let __v_390: G = G::from_u64(256); - let __v_391: G = (__v_390 * __v_140); - let __v_392: G = G::from_u64(65536); - let __v_393: G = (__v_392 * __v_141); - let __v_394: G = G::from_u64(16777216); - let __v_395: G = (__v_394 * __v_142); - let __v_396: G = (__v_393 + __v_395); - let __v_397: G = (__v_391 + __v_396); - let __v_398: G = (__v_139 + __v_397); - let __v_399: G = G::from_u64(256); - let __v_400: G = (__v_399 * __v_144); - let __v_401: G = G::from_u64(65536); - let __v_402: G = (__v_401 * __v_145); - let __v_403: G = G::from_u64(16777216); - let __v_404: G = (__v_403 * __v_146); - let __v_405: G = (__v_402 + __v_404); - let __v_406: G = (__v_400 + __v_405); - let __v_407: G = (__v_143 + __v_406); - let __v_408: G = G::from_u64(256); - let __v_409: G = (__v_408 * __v_148); - let __v_410: G = G::from_u64(65536); - let __v_411: G = (__v_410 * __v_149); - let __v_412: G = G::from_u64(16777216); - let __v_413: G = (__v_412 * __v_150); - let __v_414: G = (__v_411 + __v_413); - let __v_415: G = (__v_409 + __v_414); - let __v_416: G = (__v_147 + __v_415); - let __v_417: G = G::from_u64(256); - let __v_418: G = (__v_417 * __v_152); - let __v_419: G = G::from_u64(65536); - let __v_420: G = (__v_419 * __v_153); - let __v_421: G = G::from_u64(16777216); - let __v_422: G = (__v_421 * __v_154); - let __v_423: G = (__v_420 + __v_422); - let __v_424: G = (__v_418 + __v_423); - let __v_425: G = (__v_151 + __v_424); - let __v_426: G = G::from_u64(256); - let __v_427: G = (__v_426 * __v_156); - let __v_428: G = G::from_u64(65536); - let __v_429: G = (__v_428 * __v_157); - let __v_430: G = G::from_u64(16777216); - let __v_431: G = (__v_430 * __v_158); - let __v_432: G = (__v_429 + __v_431); - let __v_433: G = (__v_427 + __v_432); - let __v_434: G = (__v_155 + __v_433); - if (__v_371 != __v_0) { - return Err(ExecError::AssertEqMismatch { lhs: __v_371.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); - } - if (__v_380 != __v_1) { - return Err(ExecError::AssertEqMismatch { lhs: __v_380.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); - } - if (__v_389 != __v_2) { - return Err(ExecError::AssertEqMismatch { lhs: __v_389.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); - } - if (__v_398 != __v_3) { - return Err(ExecError::AssertEqMismatch { lhs: __v_398.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); - } - if (__v_407 != __v_4) { - return Err(ExecError::AssertEqMismatch { lhs: __v_407.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); - } - if (__v_416 != __v_5) { - return Err(ExecError::AssertEqMismatch { lhs: __v_416.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); - } - if (__v_425 != __v_6) { - return Err(ExecError::AssertEqMismatch { lhs: __v_425.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); - } - if (__v_434 != __v_7) { - return Err(ExecError::AssertEqMismatch { lhs: __v_434.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); + let __v_409: G = __mc_out___mc_1[0]; + let __v_410: G = (__v_18 + __v_19); + if (__v_69 != __v_410) { + return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_410.as_canonical_u64(), msg: None }); + } + let __v_411: G = G::from_u64(256); + let __v_412: G = (__v_411 * __v_128); + let __v_413: G = G::from_u64(65536); + let __v_414: G = (__v_413 * __v_129); + let __v_415: G = G::from_u64(16777216); + let __v_416: G = (__v_415 * __v_130); + let __v_417: G = (__v_414 + __v_416); + let __v_418: G = (__v_412 + __v_417); + let __v_419: G = (__v_127 + __v_418); + let __v_420: G = G::from_u64(256); + let __v_421: G = (__v_420 * __v_132); + let __v_422: G = G::from_u64(65536); + let __v_423: G = (__v_422 * __v_133); + let __v_424: G = G::from_u64(16777216); + let __v_425: G = (__v_424 * __v_134); + let __v_426: G = (__v_423 + __v_425); + let __v_427: G = (__v_421 + __v_426); + let __v_428: G = (__v_131 + __v_427); + let __v_429: G = G::from_u64(256); + let __v_430: G = (__v_429 * __v_136); + let __v_431: G = G::from_u64(65536); + let __v_432: G = (__v_431 * __v_137); + let __v_433: G = G::from_u64(16777216); + let __v_434: G = (__v_433 * __v_138); + let __v_435: G = (__v_432 + __v_434); + let __v_436: G = (__v_430 + __v_435); + let __v_437: G = (__v_135 + __v_436); + let __v_438: G = G::from_u64(256); + let __v_439: G = (__v_438 * __v_140); + let __v_440: G = G::from_u64(65536); + let __v_441: G = (__v_440 * __v_141); + let __v_442: G = G::from_u64(16777216); + let __v_443: G = (__v_442 * __v_142); + let __v_444: G = (__v_441 + __v_443); + let __v_445: G = (__v_439 + __v_444); + let __v_446: G = (__v_139 + __v_445); + let __v_447: G = G::from_u64(256); + let __v_448: G = (__v_447 * __v_144); + let __v_449: G = G::from_u64(65536); + let __v_450: G = (__v_449 * __v_145); + let __v_451: G = G::from_u64(16777216); + let __v_452: G = (__v_451 * __v_146); + let __v_453: G = (__v_450 + __v_452); + let __v_454: G = (__v_448 + __v_453); + let __v_455: G = (__v_143 + __v_454); + let __v_456: G = G::from_u64(256); + let __v_457: G = (__v_456 * __v_148); + let __v_458: G = G::from_u64(65536); + let __v_459: G = (__v_458 * __v_149); + let __v_460: G = G::from_u64(16777216); + let __v_461: G = (__v_460 * __v_150); + let __v_462: G = (__v_459 + __v_461); + let __v_463: G = (__v_457 + __v_462); + let __v_464: G = (__v_147 + __v_463); + let __v_465: G = G::from_u64(256); + let __v_466: G = (__v_465 * __v_152); + let __v_467: G = G::from_u64(65536); + let __v_468: G = (__v_467 * __v_153); + let __v_469: G = G::from_u64(16777216); + let __v_470: G = (__v_469 * __v_154); + let __v_471: G = (__v_468 + __v_470); + let __v_472: G = (__v_466 + __v_471); + let __v_473: G = (__v_151 + __v_472); + let __v_474: G = G::from_u64(256); + let __v_475: G = (__v_474 * __v_156); + let __v_476: G = G::from_u64(65536); + let __v_477: G = (__v_476 * __v_157); + let __v_478: G = G::from_u64(16777216); + let __v_479: G = (__v_478 * __v_158); + let __v_480: G = (__v_477 + __v_479); + let __v_481: G = (__v_475 + __v_480); + let __v_482: G = (__v_155 + __v_481); + if (__v_419 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_419.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None }); + } + if (__v_428 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_428.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None }); + } + if (__v_437 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_437.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None }); + } + if (__v_446 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_446.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None }); + } + if (__v_455 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_455.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None }); + } + if (__v_464 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_464.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None }); + } + if (__v_473 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_473.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None }); + } + if (__v_482 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_482.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_263.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_435: G = __loaded[0]; - let __v_436: G = __loaded[1]; - let __v_437: G = __loaded[2]; - let __v_438: G = G::from_u64(1); - let __v_439: G = G::from_u64(1); - if (__v_435 != __v_438) { - return Err(ExecError::AssertEqMismatch { lhs: __v_435.as_canonical_u64(), rhs: __v_438.as_canonical_u64(), msg: None }); - } - if (__v_436 != __v_439) { - return Err(ExecError::AssertEqMismatch { lhs: __v_436.as_canonical_u64(), rhs: __v_439.as_canonical_u64(), msg: None }); - } - if (__v_437 != __v_439) { - return Err(ExecError::AssertEqMismatch { lhs: __v_437.as_canonical_u64(), rhs: __v_439.as_canonical_u64(), msg: None }); - } - let __v_440: G = G::from_u64(256); - let __v_441: G = (__v_440 * __v_325); - let __v_442: G = G::from_u64(65536); - let __v_443: G = (__v_442 * __v_326); - let __v_444: G = G::from_u64(16777216); - let __v_445: G = (__v_444 * __v_327); - let __v_446: G = (__v_443 + __v_445); - let __v_447: G = (__v_441 + __v_446); - let __v_448: G = (__v_324 + __v_447); - let __v_449: G = G::from_u64(256); - let __v_450: G = (__v_449 * __v_329); - let __v_451: G = G::from_u64(65536); - let __v_452: G = (__v_451 * __v_330); - let __v_453: G = G::from_u64(16777216); - let __v_454: G = (__v_453 * __v_331); - let __v_455: G = (__v_452 + __v_454); - let __v_456: G = (__v_450 + __v_455); - let __v_457: G = (__v_328 + __v_456); - let __v_458: G = G::from_u64(256); - let __v_459: G = (__v_458 * __v_333); - let __v_460: G = G::from_u64(65536); - let __v_461: G = (__v_460 * __v_334); - let __v_462: G = G::from_u64(16777216); - let __v_463: G = (__v_462 * __v_335); - let __v_464: G = (__v_461 + __v_463); - let __v_465: G = (__v_459 + __v_464); - let __v_466: G = (__v_332 + __v_465); - let __v_467: G = G::from_u64(256); - let __v_468: G = (__v_467 * __v_337); - let __v_469: G = G::from_u64(65536); - let __v_470: G = (__v_469 * __v_338); - let __v_471: G = G::from_u64(16777216); - let __v_472: G = (__v_471 * __v_339); - let __v_473: G = (__v_470 + __v_472); - let __v_474: G = (__v_468 + __v_473); - let __v_475: G = (__v_336 + __v_474); - let __v_476: G = G::from_u64(256); - let __v_477: G = (__v_476 * __v_341); - let __v_478: G = G::from_u64(65536); - let __v_479: G = (__v_478 * __v_342); - let __v_480: G = G::from_u64(16777216); - let __v_481: G = (__v_480 * __v_343); - let __v_482: G = (__v_479 + __v_481); - let __v_483: G = (__v_477 + __v_482); - let __v_484: G = (__v_340 + __v_483); - let __v_485: G = G::from_u64(256); - let __v_486: G = (__v_485 * __v_345); - let __v_487: G = G::from_u64(65536); - let __v_488: G = (__v_487 * __v_346); - let __v_489: G = G::from_u64(16777216); - let __v_490: G = (__v_489 * __v_347); - let __v_491: G = (__v_488 + __v_490); - let __v_492: G = (__v_486 + __v_491); - let __v_493: G = (__v_344 + __v_492); - let __v_494: G = G::from_u64(256); - let __v_495: G = (__v_494 * __v_349); - let __v_496: G = G::from_u64(65536); - let __v_497: G = (__v_496 * __v_350); - let __v_498: G = G::from_u64(16777216); - let __v_499: G = (__v_498 * __v_351); - let __v_500: G = (__v_497 + __v_499); - let __v_501: G = (__v_495 + __v_500); - let __v_502: G = (__v_348 + __v_501); - let __v_503: G = G::from_u64(256); - let __v_504: G = (__v_503 * __v_353); - let __v_505: G = G::from_u64(65536); - let __v_506: G = (__v_505 * __v_354); - let __v_507: G = G::from_u64(16777216); - let __v_508: G = (__v_507 * __v_355); - let __v_509: G = (__v_506 + __v_508); - let __v_510: G = (__v_504 + __v_509); - let __v_511: G = (__v_352 + __v_510); - if (__v_448 != __v_8) { - return Err(ExecError::AssertEqMismatch { lhs: __v_448.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); - } - if (__v_457 != __v_9) { - return Err(ExecError::AssertEqMismatch { lhs: __v_457.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); - } - if (__v_466 != __v_10) { - return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); - } - if (__v_475 != __v_11) { - return Err(ExecError::AssertEqMismatch { lhs: __v_475.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); - } - if (__v_484 != __v_12) { - return Err(ExecError::AssertEqMismatch { lhs: __v_484.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); - } - if (__v_493 != __v_13) { - return Err(ExecError::AssertEqMismatch { lhs: __v_493.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); - } - if (__v_502 != __v_14) { - return Err(ExecError::AssertEqMismatch { lhs: __v_502.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); - } - if (__v_511 != __v_15) { - return Err(ExecError::AssertEqMismatch { lhs: __v_511.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_359.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_512: G = __loaded[0]; - let __v_513: G = __loaded[1]; - let __v_514: G = __loaded[2]; - let __v_515: G = G::from_u64(1); - let __v_516: G = G::from_u64(1); - if (__v_512 != __v_515) { - return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_515.as_canonical_u64(), msg: None }); - } - if (__v_513 != __v_516) { - return Err(ExecError::AssertEqMismatch { lhs: __v_513.as_canonical_u64(), rhs: __v_516.as_canonical_u64(), msg: None }); - } - if (__v_514 != __v_516) { - return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_516.as_canonical_u64(), msg: None }); - } - let __v_517: G = G::from_u64(1); - if (__v_360 != __v_517) { - return Err(ExecError::AssertEqMismatch { lhs: __v_360.as_canonical_u64(), rhs: __v_517.as_canonical_u64(), msg: None }); - } - let __v_518: G = G::from_u64(1); - if (__v_361 != __v_518) { - return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_518.as_canonical_u64(), msg: None }); + let __v_483: G = __loaded[0]; + let __v_484: G = __loaded[1]; + let __v_485: G = __loaded[2]; + let __v_486: G = G::from_u64(1); + let __v_487: G = G::from_u64(1); + if (__v_483 != __v_486) { + return Err(ExecError::AssertEqMismatch { lhs: __v_483.as_canonical_u64(), rhs: __v_486.as_canonical_u64(), msg: None }); + } + if (__v_484 != __v_487) { + return Err(ExecError::AssertEqMismatch { lhs: __v_484.as_canonical_u64(), rhs: __v_487.as_canonical_u64(), msg: None }); + } + if (__v_485 != __v_487) { + return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_487.as_canonical_u64(), msg: None }); + } + let __v_488: G = G::from_u64(256); + let __v_489: G = (__v_488 * __v_373); + let __v_490: G = G::from_u64(65536); + let __v_491: G = (__v_490 * __v_374); + let __v_492: G = G::from_u64(16777216); + let __v_493: G = (__v_492 * __v_375); + let __v_494: G = (__v_491 + __v_493); + let __v_495: G = (__v_489 + __v_494); + let __v_496: G = (__v_372 + __v_495); + let __v_497: G = G::from_u64(256); + let __v_498: G = (__v_497 * __v_377); + let __v_499: G = G::from_u64(65536); + let __v_500: G = (__v_499 * __v_378); + let __v_501: G = G::from_u64(16777216); + let __v_502: G = (__v_501 * __v_379); + let __v_503: G = (__v_500 + __v_502); + let __v_504: G = (__v_498 + __v_503); + let __v_505: G = (__v_376 + __v_504); + let __v_506: G = G::from_u64(256); + let __v_507: G = (__v_506 * __v_381); + let __v_508: G = G::from_u64(65536); + let __v_509: G = (__v_508 * __v_382); + let __v_510: G = G::from_u64(16777216); + let __v_511: G = (__v_510 * __v_383); + let __v_512: G = (__v_509 + __v_511); + let __v_513: G = (__v_507 + __v_512); + let __v_514: G = (__v_380 + __v_513); + let __v_515: G = G::from_u64(256); + let __v_516: G = (__v_515 * __v_385); + let __v_517: G = G::from_u64(65536); + let __v_518: G = (__v_517 * __v_386); + let __v_519: G = G::from_u64(16777216); + let __v_520: G = (__v_519 * __v_387); + let __v_521: G = (__v_518 + __v_520); + let __v_522: G = (__v_516 + __v_521); + let __v_523: G = (__v_384 + __v_522); + let __v_524: G = G::from_u64(256); + let __v_525: G = (__v_524 * __v_389); + let __v_526: G = G::from_u64(65536); + let __v_527: G = (__v_526 * __v_390); + let __v_528: G = G::from_u64(16777216); + let __v_529: G = (__v_528 * __v_391); + let __v_530: G = (__v_527 + __v_529); + let __v_531: G = (__v_525 + __v_530); + let __v_532: G = (__v_388 + __v_531); + let __v_533: G = G::from_u64(256); + let __v_534: G = (__v_533 * __v_393); + let __v_535: G = G::from_u64(65536); + let __v_536: G = (__v_535 * __v_394); + let __v_537: G = G::from_u64(16777216); + let __v_538: G = (__v_537 * __v_395); + let __v_539: G = (__v_536 + __v_538); + let __v_540: G = (__v_534 + __v_539); + let __v_541: G = (__v_392 + __v_540); + let __v_542: G = G::from_u64(256); + let __v_543: G = (__v_542 * __v_397); + let __v_544: G = G::from_u64(65536); + let __v_545: G = (__v_544 * __v_398); + let __v_546: G = G::from_u64(16777216); + let __v_547: G = (__v_546 * __v_399); + let __v_548: G = (__v_545 + __v_547); + let __v_549: G = (__v_543 + __v_548); + let __v_550: G = (__v_396 + __v_549); + let __v_551: G = G::from_u64(256); + let __v_552: G = (__v_551 * __v_401); + let __v_553: G = G::from_u64(65536); + let __v_554: G = (__v_553 * __v_402); + let __v_555: G = G::from_u64(16777216); + let __v_556: G = (__v_555 * __v_403); + let __v_557: G = (__v_554 + __v_556); + let __v_558: G = (__v_552 + __v_557); + let __v_559: G = (__v_400 + __v_558); + if (__v_496 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_496.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); + } + if (__v_505 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_505.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None }); + } + if (__v_514 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None }); + } + if (__v_523 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); + } + if (__v_532 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_532.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None }); + } + if (__v_541 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_541.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None }); + } + if (__v_550 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_550.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None }); + } + if (__v_559 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_559.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); + } + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_407.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_560: G = __loaded[0]; + let __v_561: G = __loaded[1]; + let __v_562: G = __loaded[2]; + let __v_563: G = G::from_u64(1); + let __v_564: G = G::from_u64(1); + if (__v_560 != __v_563) { + return Err(ExecError::AssertEqMismatch { lhs: __v_560.as_canonical_u64(), rhs: __v_563.as_canonical_u64(), msg: None }); + } + if (__v_561 != __v_564) { + return Err(ExecError::AssertEqMismatch { lhs: __v_561.as_canonical_u64(), rhs: __v_564.as_canonical_u64(), msg: None }); + } + if (__v_562 != __v_564) { + return Err(ExecError::AssertEqMismatch { lhs: __v_562.as_canonical_u64(), rhs: __v_564.as_canonical_u64(), msg: None }); + } + let __v_565: G = G::from_u64(1); + if (__v_408 != __v_565) { + return Err(ExecError::AssertEqMismatch { lhs: __v_408.as_canonical_u64(), rhs: __v_565.as_canonical_u64(), msg: None }); + } + let __v_566: G = G::from_u64(1); + if (__v_409 != __v_566) { + return Err(ExecError::AssertEqMismatch { lhs: __v_409.as_canonical_u64(), rhs: __v_566.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_241] = []; if !unconstrained { record.virt += record.function_queries[241].weight(); } record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap); From 54da708f12a7d1e07d19716e9000cb78cb5df553 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Wed, 2 Sep 2026 09:09:28 -0400 Subject: [PATCH 34/44] Calibrate Aiur prover RSS envelope from Mathlib --- crates/aiur/src/synthesis.rs | 37 ++++++++++++++++++++++++++++++------ 1 file changed, 31 insertions(+), 6 deletions(-) diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index bfe709f6f..c78ecc1cf 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -38,6 +38,22 @@ pub struct PeakProveBytes { pub peak: usize, } +// The allocation-schedule model below is deliberately structural, but the +// process RSS also contains allocator/runtime residency that it does not name. +// Across the 168 completed Mathlib shard proofs at multi-stark 2892243e, +// measured RSS / analytic peak had median 1.0678 and maximum under-prediction +// 1.0714. A 7.5% envelope covers the full sample with a small margin. +const PROVER_RSS_CALIBRATION_NUMERATOR: usize = 43; +const PROVER_RSS_CALIBRATION_DENOMINATOR: usize = 40; + +fn calibrate_prover_rss(analytic_peak: usize) -> usize { + analytic_peak + .checked_mul(PROVER_RSS_CALIBRATION_NUMERATOR) + .map_or(usize::MAX, |scaled| { + scaled.div_ceil(PROVER_RSS_CALIBRATION_DENOMINATOR) + }) +} + /// Outcome of a budget-gated prove /// ([`AiurSystem::prove_ixvm_within_budget`]). Only the case that ran a /// STARK carries a proof; the other two report the measured peak the @@ -249,10 +265,9 @@ impl AiurSystem { /// Predicted peak prover resident bytes for a record, from circuit /// shapes alone — the analytic counterpart of an empirical GiB-per-fft /// line. Mirrors this system's actual allocation schedule (multi-stark - /// rev `be1755e`, the workspace pin; an upstream allocation-schedule + /// rev `2892243e`, the workspace pin; an upstream allocation-schedule /// change skews every prediction, so re-validate against a measured - /// prove when bumping multi-stark — real proves at ~472 GiB measured - /// +1.6-1.7% over prediction): + /// prove when bumping multi-stark): /// /// 1. WITNESS phase: the `QueryRecord` plus every circuit's padded main /// trace and base-field lookup witness, built in parallel and all @@ -265,8 +280,10 @@ impl AiurSystem { /// retained FRI fold layers (geometric in `max_log_arity`), and the /// open-phase buffers — all proportional to `H = blowup · tallest`. /// - /// The peak is the max of the three plus the preprocessed-gadget - /// residency committed at setup. Heights are `next_power_of_two` of the + /// The analytic peak is the max of the three plus the + /// preprocessed-gadget residency committed at setup. The returned `peak` + /// additionally applies [`calibrate_prover_rss`] to cover measured + /// allocator/runtime residency. Heights are `next_power_of_two` of the /// record's unique queries — the padding the trace actually commits, /// which per-fft models blur. pub fn peak_prove_bytes(&self, record: &QueryRecord) -> PeakProveBytes { @@ -327,12 +344,13 @@ impl AiurSystem { // Trees (3 rounds) + retained FRI fold layers + open buffers, all ∝ H. let fri_layers = (2 * S + 2 * DG) * h * fold / (fold - 1).max(1); let phase_open = committed + 3 * 2 * DG * h + fri_layers + 11 * S * h; + let analytic_peak = phase_witness.max(phase_stage2).max(phase_open) + prep; PeakProveBytes { phase_witness, phase_stage2, phase_open, preprocessed: prep, - peak: phase_witness.max(phase_stage2).max(phase_open) + prep, + peak: calibrate_prover_rss(analytic_peak), } } @@ -637,6 +655,13 @@ mod tests { }; use rustc_hash::FxHashMap; + #[test] + fn prover_rss_calibration_rounds_up_and_saturates() { + assert_eq!(calibrate_prover_rss(40), 43); + assert_eq!(calibrate_prover_rss(1_000), 1_075); + assert_eq!(calibrate_prover_rss(usize::MAX), usize::MAX); + } + /// Small FRI parameters mirroring `vk_codec`'s test config: cheap to prove /// while still exercising the full FRI pipeline (log_blowup 1, 64 queries, /// no proof-of-work). From 9a88bac9df5b7ff9dff4d2b2a9448831ce0d5933 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Wed, 2 Sep 2026 13:55:37 -0400 Subject: [PATCH 35/44] Parallelize aggregate startup --- Ix/Cli/AggregateCmd.lean | 153 ++++++++++++++++++++++++++++++--------- Tests/AggrSemantics.lean | 12 +++ 2 files changed, 132 insertions(+), 33 deletions(-) diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index 85e0076ce..41490c53a 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -458,13 +458,30 @@ private def addrOfHex (label value : String) : Except String Address := | none => .error s!"{label}: expected a 64-character address, got {value.length} characters" -private def prepareShard (env : Ixon.Env) (blocks : Array Address) : +private def prepareOwnedShard (env : Ixon.Env) (owned : 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 } +/-- Reconstruct every shard statement after partitioning environment ownership +in one pass. Calling `ownedConstsForBlocks` once per shard rescans the complete +environment for every leaf, which made Mathlib aggregate startup take more +than twenty minutes before the proof store was touched. -/ +def prepareShards (env : Ixon.Env) (shards : Array (Array Address)) + (shardIds : Array Nat := #[]) : Except String (Array PreparedShard) := do + let ownedAll := Ix.Cli.CheckCmd.ownedConstsPer env shards + if ownedAll.size != shards.size then + throw s!"internal: prepared ownership for {ownedAll.size} shards, expected {shards.size}" + let mut prepared : Array PreparedShard := #[] + for (owned, shard) in ownedAll.mapIdx fun shard owned => (owned, shard) do + let originalShard := (shardIds[shard]?).getD shard + let item ← match prepareOwnedShard env owned with + | .error e => throw s!"prepare shard {originalShard}: {e}" + | .ok item => pure item + prepared := prepared.push item + pure prepared + private def compileToplevel (label : String) (source : Except Aiur.Global Aiur.Source.Toplevel) : IO (Except String Aiur.CompiledToplevel) := do @@ -474,6 +491,49 @@ private def compileToplevel (label : String) | .error e => return Except.error s!"{label} compilation failed: {e}" | .ok compiled => return Except.ok compiled +private structure AggregateBackend where + compiled : Aiur.CompiledToplevel + system : Aiur.AiurSystem + vk : ByteArray + +/-- Compile a Lean-authored Aiur program, then perform the Rust-side system +construction and verifying-key serialization in the same worker. Keeping this +pipeline together lets the independent IxVM and recursion backends build in +parallel instead of serializing their Rust setup on the controller thread. -/ +private def buildAggregateBackend (label : String) + (source : Except Aiur.Global Aiur.Source.Toplevel) + (commitment : Aiur.CommitmentParameters) (fri : Aiur.FriParameters) : + IO (Except String AggregateBackend) := do + let compiled ← match ← compileToplevel label source with + | .error e => return .error e + | .ok compiled => pure compiled + let system := Aiur.AiurSystem.build compiled.bytecode commitment fri + let vk := system.vkBytes + return .ok { compiled, system, vk } + +private structure LoadedShardProof where + address : Address + wrapper : Ixon.Proof + +private def loadShardProofs (proofHexes : List String) : + IO (Except String (Array LoadedShardProof)) := do + let mut loaded : Array LoadedShardProof := #[] + for proofHex in proofHexes do + let proofAddress ← match addrOfHex "shard proof" proofHex with + | .error e => return .error e + | .ok address => pure address + let wrapper ← match Ixon.Proof.de (← StoreIO.toIO (Store.read proofAddress)) with + | .error e => + return .error s!"decode shard proof {proofAddress}: {e}" + | .ok wrapper => pure wrapper + loaded := loaded.push { address := proofAddress, wrapper } + return .ok loaded + +private def timed {α : Type} (action : IO α) : IO (α × Nat) := do + let started ← IO.monoMsNow + let result ← action + pure (result, (← IO.monoMsNow) - started) + /-- Execute a post-order aggregate plan as a dependency-driven DAG. The controller is the sole owner of completion and reservation state: it admits a heaviest-first batch, starts one dedicated task per slot, then releases child @@ -857,6 +917,8 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) p.printError "error: aggregate requires --ixes " return 1 + let startupStarted ← IO.monoMsNow + let rawView ← match Ix.Cli.CheckCmd.parseIxesManifest (← IO.FS.readBinFile manifestPath) with | .error e => IO.eprintln s!"manifest parse failed: {e}"; return 1 @@ -903,33 +965,66 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) 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 := #[] + -- Statement preparation, proof loading, and the two independent backend + -- setup pipelines have no data dependencies. Run all four branches together, + -- then join every task before selecting a deterministic error to report. + let parallelStarted ← IO.monoMsNow + let prepareTask ← IO.asTask (prio := .dedicated) do + timed do pure (prepareShards env view.shards view.shardIds) + let proofsTask ← IO.asTask (prio := .dedicated) do + timed (loadShardProofs proofHexes) + let ixvmBackendTask ← IO.asTask (prio := .dedicated) do + timed (buildAggregateBackend "IxVM" IxVM.ixVM + Aiur.defaultCommitmentParameters Aiur.defaultFriParameters) + let aggrBackendTask ← IO.asTask (prio := .dedicated) do + timed (buildAggregateBackend "ixAggr recursion" Aggr.ixAggr + recursionParameters.commitment recursionParameters.fri) + + let prepareOutcome := prepareTask.get + let proofsOutcome := proofsTask.get + let ixvmBackendOutcome := ixvmBackendTask.get + let aggrBackendOutcome := aggrBackendTask.get + let (prepareResult, prepareMs) ← IO.ofExcept prepareOutcome + let (proofsResult, proofsMs) ← IO.ofExcept proofsOutcome + let (ixvmBackendResult, ixvmBackendMs) ← IO.ofExcept ixvmBackendOutcome + let (aggrBackendResult, aggrBackendMs) ← IO.ofExcept aggrBackendOutcome + let parallelMs := (← IO.monoMsNow) - parallelStarted + let startupMs := (← IO.monoMsNow) - startupStarted + IO.println s!"[aggregate] startup: parse/plan {parallelStarted - startupStarted}ms; \ + parallel wall {parallelMs}ms (prepare {prepareMs}ms, proofs {proofsMs}ms, \ + IxVM backend {ixvmBackendMs}ms, ixAggr backend {aggrBackendMs}ms); \ + total {startupMs}ms" + (← IO.getStdout).flush + + let prepared ← match prepareResult with + | .error e => IO.eprintln e; return 1 + | .ok prepared => pure prepared + let loadedProofs ← match proofsResult with + | .error e => IO.eprintln e; return 1 + | .ok loaded => pure loaded + let ixvmBackend ← match ixvmBackendResult with + | .error e => IO.eprintln e; return 1 + | .ok backend => pure backend + let aggrBackend ← match aggrBackendResult with + | .error e => IO.eprintln e; return 1 + | .ok backend => pure backend + + -- Proof arguments may be in any order. Match them by their bundled claim and + -- reject duplicates/missing shards before starting an expensive wrap. let mut digestToShard : Std.HashMap Address Nat := {} - for (blocks, shard) in view.shards.mapIdx fun shard blocks => (blocks, shard) do + for (item, shard) in prepared.mapIdx fun shard item => (item, 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 + for loaded in loadedProofs do + let proofAddress := loaded.address + let wrapper := loaded.wrapper let digest := Address.blake3 (Ix.Claim.ser wrapper.claim) let some shard := digestToShard.get? digest | do IO.eprintln s!"proof {proofAddress} claim {digest} matches no manifest shard" @@ -949,20 +1044,12 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) 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 verifyIdx := ixvmBackend.compiled.getFuncIdx `verify_claim |>.get! + let aggrIdx := aggrBackend.compiled.getFuncIdx `ix_aggr |>.get! + let ixvmSystem := ixvmBackend.system + let aggrSystem := aggrBackend.system + let ixvmVk := ixvmBackend.vk + let aggrVk := aggrBackend.vk let allowed := Aggr.allowedBlob ixvmVk verifyIdx aggrVk aggrIdx let specs ← match buildAggrSlotSpecs plan prepared aggrVk allowed verifyIdx aggrIdx recursionParameters with diff --git a/Tests/AggrSemantics.lean b/Tests/AggrSemantics.lean index ac79b3edc..0fe5295ad 100644 --- a/Tests/AggrSemantics.lean +++ b/Tests/AggrSemantics.lean @@ -325,6 +325,16 @@ def semanticSuite : IO UInt32 := do let pairCoverage ← match pairManifest with | .ok view => Ix.Cli.CheckCmd.shardsCover pairEnv view.shards | .error _ => pure false + let batchedShardPreparationCorrect : Bool := match pairManifest with + | .ok view => + match Ix.Cli.AggregateCmd.prepareShards pairEnv view.shards view.shardIds with + | .ok prepared => + prepared.map (·.claim) == (#[(.checkEnv + (canonicalTree #[pairLeft]).root none : Ix.Claim), + .checkEnv (canonicalTree #[pairRight]).root none] : Array Ix.Claim) && + prepared.all fun item => item.statement.claim == item.claim + | .error _ => false + | .error _ => false let flatManifestValue : Option Aggr.CheckEnvTrees := match pairManifest with | .ok view => (Ix.Cli.VerifyCmd.expectedFromManifest pairEnv view 8).toOption | .error _ => none @@ -547,6 +557,8 @@ def semanticSuite : IO UInt32 := do emptyPruningCorrect, test "one retained shard reconstructs one value-based root" singletonValueRoot, test "two-shard manifest passes exact environment coverage" pairCoverage, + test "aggregate startup prepares every shard from one ownership pass" + batchedShardPreparationCorrect, test "flat manifest value equals the canonical environment root" manifestFlatIsCanonical, test "structural manifest value equals the manifest-relative hybrid root" From 955744b53151d162f40d8a8f6cd504a300c77f71 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Wed, 2 Sep 2026 14:14:48 -0400 Subject: [PATCH 36/44] Defer aggregate setup into worker tasks --- Ix/Cli/AggregateCmd.lean | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index 41490c53a..aa4225080 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -501,9 +501,10 @@ construction and verifying-key serialization in the same worker. Keeping this pipeline together lets the independent IxVM and recursion backends build in parallel instead of serializing their Rust setup on the controller thread. -/ private def buildAggregateBackend (label : String) - (source : Except Aiur.Global Aiur.Source.Toplevel) + (source : Unit → Except Aiur.Global Aiur.Source.Toplevel) (commitment : Aiur.CommitmentParameters) (fri : Aiur.FriParameters) : IO (Except String AggregateBackend) := do + let source ← IO.lazyPure source let compiled ← match ← compileToplevel label source with | .error e => return .error e | .ok compiled => pure compiled @@ -970,14 +971,14 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) -- then join every task before selecting a deterministic error to report. let parallelStarted ← IO.monoMsNow let prepareTask ← IO.asTask (prio := .dedicated) do - timed do pure (prepareShards env view.shards view.shardIds) + timed (IO.lazyPure fun _ => prepareShards env view.shards view.shardIds) let proofsTask ← IO.asTask (prio := .dedicated) do timed (loadShardProofs proofHexes) let ixvmBackendTask ← IO.asTask (prio := .dedicated) do - timed (buildAggregateBackend "IxVM" IxVM.ixVM + timed (buildAggregateBackend "IxVM" (fun _ => IxVM.ixVM) Aiur.defaultCommitmentParameters Aiur.defaultFriParameters) let aggrBackendTask ← IO.asTask (prio := .dedicated) do - timed (buildAggregateBackend "ixAggr recursion" Aggr.ixAggr + timed (buildAggregateBackend "ixAggr recursion" (fun _ => Aggr.ixAggr) recursionParameters.commitment recursionParameters.fri) let prepareOutcome := prepareTask.get From 77d132d80c65efd9d7d65136a7f4e3466e36ab9a Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Wed, 2 Sep 2026 14:51:01 -0400 Subject: [PATCH 37/44] Move Stage 2 orchestration to Rust --- Ix/Aiur/Protocol.lean | 15 + Ix/Cli/AggregateCmd.lean | 76 +- Tests/AggrSemantics.lean | 36 + crates/ffi/src/aiur.rs | 1 + crates/ffi/src/aiur/aggregate.rs | 1811 ++++++++++++++++++++++++++++++ 5 files changed, 1938 insertions(+), 1 deletion(-) create mode 100644 crates/ffi/src/aiur/aggregate.rs diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index ce5ac1d0e..543861de7 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -196,6 +196,21 @@ opaque proveIxAggr (system : @& AiurSystem) (preimagesBlob treesBlob pathsBlob : @& ByteArray) (useBytecode : Bool := false) : Except String (Array G × Proof) +/-- Run the production aggregate-first Stage 2 pipeline natively after Lean +has compiled the IxVM and `ix_aggr` systems. Rust owns all data-dependent +orchestration: manifest/environment binding, shard-claim reconstruction, +statement folding, cache validation, dependency scheduling, recursive advice, +proving, and persistence. `proofHexes` is one store address per line; +`cacheFriBytes` is the stable 40-byte recursion-FRI cache identity. Returns the +persisted root proof address. -/ +@[extern "rs_aiur_stage2_aggregate"] +opaque aggregateStage2 (ixvmSystem aggrSystem : @& AiurSystem) + (envHandle : @& EnvHandle) (manifestPath proofHexes : @& String) + (verifyIdx aggrIdx jobs ramBudgetBytes structuralAbove : @& Nat) + (directJoins planOnly : Bool) (cacheFriBytes : @& ByteArray) + (useCache : Bool) : + Except String String + @[extern "rs_aiur_system_prove_addr_with_env"] private opaque proveAddrWithEnv' : @& AiurSystem → @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index aa4225080..e081ac716 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -905,11 +905,79 @@ private def proveAggregateSlot (ctx : AggregateProveContext) (slotIdx : Nat) claimsBytes := MultiStark.serializeClaims #[spec.outerClaim] } +/-- Production Stage 2 entrypoint. The Lean-authored circuit sources still +compile here, in parallel with mmap-loading the environment. Once both Aiur +systems exist, one FFI call transfers the complete data-dependent pipeline to +Rust; no Lean statement tree or scheduler task survives on this path. -/ +private def runAggregateCmdNativeWith + (recursionParameters : MultiStark.RecursionParameters) + (p : Cli.Parsed) : IO UInt32 := do + let some ixePath := (p.flag? "ixe").map (·.as! String) | do + p.printError "error: aggregate requires --ixe " + return 1 + let some manifestPath := (p.flag? "ixes").map (·.as! String) | do + p.printError "error: aggregate requires --ixes " + return 1 + let maxRamGb? := (p.flag? "max-ram").map (·.as! Nat) + if maxRamGb? == some 0 then + IO.eprintln "error: --max-ram must be positive" + return 1 + let ramBudgetBytes ← match maxRamGb? with + | some gib => pure (gib * aggregateGiB) + | none => defaultAggregateRamBudgetBytes + let jobs := ((p.flag? "jobs").map (·.as! Nat)).getD 0 + let structuralAbove := ((p.flag? "structural-above").map (·.as! Nat)).getD + defaultStructuralAbove + let proofHexes := String.intercalate "\n" + (p.variableArgsAs! String).toList + + let setupStarted ← IO.monoMsNow + let envTask ← IO.asTask (prio := .dedicated) do + timed (IO.lazyPure fun _ => Aiur.EnvHandle.fromIxe ixePath) + let ixvmBackendTask ← IO.asTask (prio := .dedicated) do + timed (buildAggregateBackend "IxVM" (fun _ => IxVM.ixVM) + Aiur.defaultCommitmentParameters Aiur.defaultFriParameters) + let aggrBackendTask ← IO.asTask (prio := .dedicated) do + timed (buildAggregateBackend "ixAggr recursion" (fun _ => Aggr.ixAggr) + recursionParameters.commitment recursionParameters.fri) + + -- Join every setup branch before selecting an error, so a failed branch + -- cannot orphan compilation work in the process. + let (envResult, envMs) ← IO.ofExcept envTask.get + let (ixvmResult, ixvmMs) ← IO.ofExcept ixvmBackendTask.get + let (aggrResult, aggrMs) ← IO.ofExcept aggrBackendTask.get + let setupMs := (← IO.monoMsNow) - setupStarted + IO.println s!"[aggregate] parallel host setup: {setupMs}ms \ + (environment {envMs}ms, IxVM backend {ixvmMs}ms, ixAggr backend {aggrMs}ms)" + (← IO.getStdout).flush + + let envHandle ← match envResult with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 + | .ok handle => pure handle + let ixvmBackend ← match ixvmResult with + | .error e => IO.eprintln e; return 1 + | .ok backend => pure backend + let aggrBackend ← match aggrResult with + | .error e => IO.eprintln e; return 1 + | .ok backend => pure backend + let verifyIdx := ixvmBackend.compiled.getFuncIdx `verify_claim |>.get! + let aggrIdx := aggrBackend.compiled.getFuncIdx `ix_aggr |>.get! + let nativeResult ← IO.lazyPure fun _ => + ixvmBackend.system.aggregateStage2 aggrBackend.system envHandle + manifestPath proofHexes verifyIdx aggrIdx jobs ramBudgetBytes + structuralAbove (p.hasFlag "direct-joins") + (p.hasFlag "plan-only") + recursionParameters.cacheFriBytes !(p.hasFlag "no-cache") + match nativeResult with + | .error e => IO.eprintln s!"aggregate failed: {e}"; return 1 + | .ok _ => return 0 + /-- Aggregate with an explicit recursion-proof configuration. The CLI wrapper below supplies `defaultRecursionParameters`; keeping this seam explicit lets a future policy or cache layer select a recursion configuration without changing the canonical IxVM proof parameters. -/ -def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) +private def runAggregateCmdLeanReferenceWith + (recursionParameters : MultiStark.RecursionParameters) (p : Cli.Parsed) : IO UInt32 := do let some ixePath := (p.flag? "ixe").map (·.as! String) | do p.printError "error: aggregate requires --ixe " @@ -1104,6 +1172,12 @@ def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) IO.println s!"[aggregate] root proof: {proofAddress}" return 0 +/-- Aggregate through the native Stage 2 controller. The retained Lean driver +above is a protocol reference and unit-test seam; it is not on the CLI path. -/ +def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters) + (p : Cli.Parsed) : IO UInt32 := + runAggregateCmdNativeWith recursionParameters p + def runAggregateCmd (p : Cli.Parsed) : IO UInt32 := runAggregateCmdWith MultiStark.defaultRecursionParameters p diff --git a/Tests/AggrSemantics.lean b/Tests/AggrSemantics.lean index 0fe5295ad..752b1e73f 100644 --- a/Tests/AggrSemantics.lean +++ b/Tests/AggrSemantics.lean @@ -182,6 +182,21 @@ def semanticSuite : IO UInt32 := do (selfVk.set! 0 (selfVk.data[0]! + 1)) childRecursionParameters leftOuter let cacheKeyBindsVersion := leftKey != Ix.Cli.AggregateCmd.aggregateCacheKey selfVk childRecursionParameters leftOuter 1 + let repeated07 : Nat := 506381209866536711 + let cacheVectorParameters : MultiStark.RecursionParameters := { + commitment := Aiur.defaultCommitmentParameters + fri := { + logFinalPolyLen := repeated07 + maxLogArity := repeated07 + numQueries := repeated07 + commitProofOfWorkBits := repeated07 + queryProofOfWorkBits := repeated07 + } + } + let cacheKeyMatchesRustVector := + toString (Ix.Cli.AggregateCmd.aggregateCacheKey "vk".toUTF8 + cacheVectorParameters #[.ofNat 1, .ofNat 2, .ofNat 3]) == + "86ed059157e2915fe0a83f1afd58f31f7553659ad778669f6b795e1473e7afe0" let ops : Array Ix.Cli.CheckCmd.AggregationTree.FoldOp := #[.leaf 0, .leaf 1, .join 0 1] @@ -317,6 +332,23 @@ def semanticSuite : IO UInt32 := do statement.claim == .checkEnv (canonicalTree #[singleAddr]).root none | .error _ => false | .error _ => false + let nativePlanOnlyFfiWorks ← do + let dir ← IO.FS.createTempDir + let ixePath := dir / "native-plan.ixe" + let ixesPath := dir / "native-plan.ixes" + match Ixon.serEnv singleEnv with + | .error _ => pure false + | .ok envBytes => + IO.FS.writeBinFile ixePath envBytes + IO.FS.writeBinFile ixesPath <| minimalIxesFor #[#[singleAddr]] + (#[1, 0] ++ u32le4 0 ++ #[0]) + match Aiur.EnvHandle.fromIxe ixePath.toString with + | .error _ => pure false + | .ok handle => + pure <| (ixvmSystem.aggregateStage2 selfSystem handle + ixesPath.toString "" verifyIdx fakeAggrIdx 1 + (16 * 1024 * 1024 * 1024) 4096 false true + childRecursionParameters.cacheFriBytes false).isOk let (pairEnv, pairLeft, pairRight) := pairIxonEnv let pairManifest := Ix.Cli.CheckCmd.parseIxesManifest @@ -522,6 +554,8 @@ def semanticSuite : IO UInt32 := do test "aggregate cache key binds recursion FRI parameters" cacheKeyBindsFri, test "aggregate cache key binds the recursion verifying key" cacheKeyBindsVk, test "aggregate cache key rejects version-1 entries" cacheKeyBindsVersion, + test "Rust and Lean aggregate cache identity share a fixed vector" + cacheKeyMatchesRustVector, test "wrap-first specs precompute every uniform claim and cache key" wrapSpecsComplete, test "direct specs retain raw IxVM leaves and one aggregate root" @@ -556,6 +590,8 @@ def semanticSuite : IO UInt32 := do test "empty manifest leaves contract and retained ids remap densely" emptyPruningCorrect, test "one retained shard reconstructs one value-based root" singletonValueRoot, + test "native Stage 2 FFI plans a serialized environment end-to-end" + nativePlanOnlyFfiWorks, test "two-shard manifest passes exact environment coverage" pairCoverage, test "aggregate startup prepares every shard from one ownership pass" batchedShardPreparationCorrect, diff --git a/crates/ffi/src/aiur.rs b/crates/ffi/src/aiur.rs index 01ad45ace..543b5f5ea 100644 --- a/crates/ffi/src/aiur.rs +++ b/crates/ffi/src/aiur.rs @@ -1,5 +1,6 @@ use multi_stark::p3_field::integers::QuotientMap; +pub mod aggregate; pub mod protocol; pub mod toplevel; diff --git a/crates/ffi/src/aiur/aggregate.rs b/crates/ffi/src/aiur/aggregate.rs new file mode 100644 index 000000000..1406af97a --- /dev/null +++ b/crates/ffi/src/aiur/aggregate.rs @@ -0,0 +1,1811 @@ +//! Native Stage 2 orchestration for `ix aggregate`. +//! +//! Lean still constructs the two Aiur bytecode systems, because their source +//! programs are Lean-authored. Everything data-dependent after that point is +//! kept here: manifest/environment binding, shard-claim reconstruction, +//! statement folding, cache validation, dependency scheduling, recursive +//! advice construction, proving, and persistence. +//! +//! The host statements deliberately cache roots and sorted leaves. Structural +//! subject trees carry only their two children and a small shard-membership +//! bitset, so deciding whether an assumption is discharged is O(1), and a +//! Merkle path is O(log n). This avoids the eager recursive `root`/`leaves`/ +//! `contains` traversals that made the former Lean startup super-linear. + +#![allow(clippy::too_many_arguments)] + +use std::{ + cmp::Ordering, + fs, + path::{Path, PathBuf}, + sync::{Arc, OnceLock, mpsc}, + thread, + time::Instant, +}; + +use aiur::{ + G, function_channel, + synthesis::{AiurProof, AiurSystem}, +}; +use ix_common::address::Address; +use ix_kernel::shard::{AggNode, ShardManifest}; +use ixon::{ + Claim, Constant, ConstantInfo, Proof as IxonProof, + assumption_tree::AssumptionTree, + merkle::{ + MerklePath, leaf_hash, merkle_root_canonical_sorted, node_hash, + zero_address, + }, + shard_claim::thin_frontier, +}; +use ixvm_codegen::{ + aiur_ix_aggr_runner::{ + AggrAdvice, AggrPath, AggrPreimage, AggrTree, aggr_io_buffer, + execute_ix_aggr, + }, + env_handle::EnvHandle, +}; +use lean_ffi::object::{ + LeanBorrowed, LeanByteArray, LeanExcept, LeanExternal, LeanNat, LeanOwned, + LeanString, +}; +use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; +use rustc_hash::{FxHashMap, FxHashSet}; + +use super::lean_unbox_nat_as_usize; + +const CACHE_VERSION: u64 = 2; +const GIB: usize = 1024 * 1024 * 1024; +const WRAP_RAM_BYTES: usize = 195 * GIB; +const STRUCTURAL_RAM_BYTES: usize = 195 * GIB; +const RAW_SHARD_RAM_BYTES: usize = 4 * GIB; +const DIRECT_RAM_BYTES: usize = 390 * GIB; +const MIXED_RAM_BYTES: usize = 340 * GIB; +const FLAT_RAM_PER_SUBJECT: usize = 1024 * 1024; + +fn format_gib(bytes: usize) -> String { + let tenths = bytes.saturating_mul(10) / GIB; + format!("{}.{:01}", tenths / 10, tenths % 10) +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum ChildKind { + Ixvm, + Aggr, +} + +impl ChildKind { + const fn code(self) -> u8 { + match self { + Self::Ixvm => 0, + Self::Aggr => 1, + } + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct ShardSet(Vec); + +impl ShardSet { + fn singleton(index: usize, shard_count: usize) -> Self { + let mut words = vec![0; shard_count.div_ceil(64)]; + words[index / 64] |= 1u64 << (index % 64); + Self(words) + } + + fn union(&self, other: &Self) -> Self { + debug_assert_eq!(self.0.len(), other.0.len()); + Self(self.0.iter().zip(&other.0).map(|(a, b)| a | b).collect()) + } + + fn contains(&self, index: usize) -> bool { + self + .0 + .get(index / 64) + .is_some_and(|word| word & (1u64 << (index % 64)) != 0) + } +} + +/// Canonical sorted tree whose expensive derivative representations are built +/// once, on demand. The root is computed once at construction. +#[derive(Debug)] +struct CanonicalTree { + leaves: Arc<[Address]>, + root: Address, + serialized: OnceLock>, + levels: OnceLock>>, +} + +impl CanonicalTree { + fn from_sorted(leaves: Vec

) -> Result>, String> { + if leaves.is_empty() { + return Ok(None); + } + if !leaves.windows(2).all(|w| w[0] < w[1]) { + return Err("canonical tree leaves are not strictly sorted".into()); + } + let root = merkle_root_canonical_sorted(&leaves) + .ok_or("nonempty canonical tree did not produce a root")?; + Ok(Some(Arc::new(Self { + leaves: leaves.into(), + root, + serialized: OnceLock::new(), + levels: OnceLock::new(), + }))) + } + + fn serialized(&self) -> &[u8] { + self.serialized.get_or_init(|| { + let tree = AssumptionTree::canonical(&self.leaves) + .expect("a nonempty canonical leaf list has a tree"); + debug_assert_eq!(tree.root(), self.root); + tree.ser() + }) + } + + fn levels(&self) -> &[Vec
] { + self.levels.get_or_init(|| { + let mut levels: Vec> = + vec![self.leaves.iter().map(leaf_hash).collect()]; + let zero = zero_address(); + while levels.last().is_some_and(|level| level.len() > 1) { + let previous = levels.last().expect("one level exists"); + let mut next = Vec::with_capacity(previous.len().div_ceil(2)); + for pair in previous.chunks(2) { + next.push(node_hash(&pair[0], pair.get(1).unwrap_or(&zero))); + } + levels.push(next); + } + levels + }) + } + + fn merkle_proof(&self, target: &Address) -> Option { + let mut position = self.leaves.binary_search(target).ok()?; + let levels = self.levels(); + let zero = zero_address(); + let mut path = Vec::with_capacity(levels.len().saturating_sub(1)); + for level in levels.iter().take(levels.len().saturating_sub(1)) { + let sibling = + level.get(position ^ 1).cloned().unwrap_or_else(|| zero.clone()); + path.push((sibling, position & 1 == 1)); + position /= 2; + } + Some(path) + } +} + +#[derive(Debug)] +enum SubjectRepr { + Canonical(Arc), + Structural { left: Arc, right: Arc }, +} + +#[derive(Debug)] +struct SubjectTree { + root: Address, + count: usize, + shards: ShardSet, + repr: SubjectRepr, +} + +impl SubjectTree { + fn canonical( + leaves: Vec
, + shards: ShardSet, + ) -> Result, String> { + let count = leaves.len(); + let canonical = CanonicalTree::from_sorted(leaves)? + .ok_or("a shard cannot have an empty subject tree")?; + Ok(Arc::new(Self { + root: canonical.root.clone(), + count, + shards, + repr: SubjectRepr::Canonical(canonical), + })) + } + + fn flat(left: &Arc, right: &Arc) -> Result, String> { + let SubjectRepr::Canonical(left_tree) = &left.repr else { + return Err("flat aggregate has a structural left child".into()); + }; + let SubjectRepr::Canonical(right_tree) = &right.repr else { + return Err("flat aggregate has a structural right child".into()); + }; + let leaves = merge_sorted(&left_tree.leaves, &right_tree.leaves); + if leaves.len() != left.count.saturating_add(right.count) { + return Err("aggregate subject sets overlap".into()); + } + Self::canonical(leaves, left.shards.union(&right.shards)) + } + + fn structural(left: Arc, right: Arc) -> Arc { + Arc::new(Self { + root: node_hash(&left.root, &right.root), + count: left.count.saturating_add(right.count), + shards: left.shards.union(&right.shards), + repr: SubjectRepr::Structural { left, right }, + }) + } + + fn canonical_tree(&self) -> Option<&CanonicalTree> { + match &self.repr { + SubjectRepr::Canonical(tree) => Some(tree), + SubjectRepr::Structural { .. } => None, + } + } + + fn merkle_proof(&self, target: &Address, owner: usize) -> Option { + if !self.shards.contains(owner) { + return None; + } + match &self.repr { + SubjectRepr::Canonical(tree) => tree.merkle_proof(target), + SubjectRepr::Structural { left, right } => { + if left.shards.contains(owner) { + let mut path = left.merkle_proof(target, owner)?; + path.push((right.root.clone(), false)); + Some(path) + } else { + let mut path = right.merkle_proof(target, owner)?; + path.push((left.root.clone(), true)); + Some(path) + } + }, + } + } + + fn collect_leaves(&self, out: &mut Vec
) { + match &self.repr { + SubjectRepr::Canonical(tree) => out.extend_from_slice(&tree.leaves), + SubjectRepr::Structural { left, right } => { + left.collect_leaves(out); + right.collect_leaves(out); + }, + } + } +} + +#[derive(Debug)] +struct Statement { + subjects: Arc, + assumptions: Option>, + claim: Claim, + claim_bytes: Vec, +} + +impl Statement { + fn new( + subjects: Arc, + assumptions: Option>, + ) -> Arc { + let claim = Claim::CheckEnv { + root: subjects.root.clone(), + assumptions: assumptions.as_ref().map(|tree| tree.root.clone()), + }; + let mut claim_bytes = Vec::new(); + claim.put(&mut claim_bytes); + Arc::new(Self { subjects, assumptions, claim, claim_bytes }) + } + + fn join( + left: &Arc, + right: &Arc, + structural: bool, + owner_by_address: &FxHashMap, + ) -> Result, String> { + let subjects = if structural { + SubjectTree::structural(left.subjects.clone(), right.subjects.clone()) + } else { + SubjectTree::flat(&left.subjects, &right.subjects)? + }; + let candidates = merge_optional_sets( + left.assumptions.as_deref(), + right.assumptions.as_deref(), + ); + let mut remaining = Vec::with_capacity(candidates.len()); + for candidate in candidates { + let owner = owner_by_address.get(&candidate).ok_or_else(|| { + format!("aggregate assumption {} has no owning shard", candidate.hex()) + })?; + if !subjects.shards.contains(*owner) { + remaining.push(candidate); + } + } + let assumptions = CanonicalTree::from_sorted(remaining)?; + Ok(Self::new(subjects, assumptions)) + } +} + +#[derive(Debug)] +struct PreparedShard { + original_id: u32, + statement: Arc, +} + +struct PreparedRun { + shards: Vec, + owner_by_address: FxHashMap, + tree: AggNode, + env_root: Address, + env_count: usize, + expected_shards: ShardSet, +} + +#[derive(Clone, Copy, Debug)] +enum PlanOp { + Leaf(usize), + Join(usize, usize), +} + +#[derive(Debug)] +struct SlotSpec { + op: PlanOp, + statement: Arc, + subject_count: usize, + structural: bool, + kind: ChildKind, + shape: Option, + outer_claim: Vec, + cache_key: Address, + ram_bytes: usize, +} + +struct Slot { + kind: ChildKind, + statement: Arc, + outer_claim: Vec, + proof: AiurProof, + proof_address: Option
, + claims_bytes: Vec, +} + +#[derive(Clone, Copy)] +struct ProveContext<'a> { + specs: &'a [SlotSpec], + prepared: &'a [PreparedShard], + proofs: &'a [Arc], + owner_by_address: &'a FxHashMap, + ixvm_system: &'a AiurSystem, + aggr_system: &'a AiurSystem, + ixvm_vk: &'a [u8], + aggr_vk: &'a [u8], + allowed: &'a [u8], + verify_idx: usize, + aggr_idx: usize, + store_dir: &'a Path, + cache_dir: Option<&'a Path>, +} + +#[derive(Clone, Copy)] +struct RunConfig<'a> { + ixvm_system: &'a AiurSystem, + aggr_system: &'a AiurSystem, + env_handle: &'a EnvHandle, + manifest_path: &'a Path, + proof_hexes: &'a str, + verify_idx: usize, + aggr_idx: usize, + jobs: usize, + ram_budget_bytes: usize, + structural_above: usize, + direct_joins: bool, + plan_only: bool, + cache_fri_bytes: &'a [u8], + use_cache: bool, +} + +fn projection_block(addr: &Address, constant: &Constant) -> Address { + match &constant.info { + ConstantInfo::IPrj(p) => p.block.clone(), + ConstantInfo::CPrj(p) => p.block.clone(), + ConstantInfo::RPrj(p) => p.block.clone(), + ConstantInfo::DPrj(p) => p.block.clone(), + _ => addr.clone(), + } +} + +fn prepare_run( + env: &ixon::Env, + manifest: &ShardManifest, +) -> Result { + if manifest.shards.is_empty() { + return Err("manifest contains no shards".into()); + } + + let mut block_to_shard = FxHashMap::default(); + let mut id_to_index = FxHashMap::default(); + for (index, shard) in manifest.shards.iter().enumerate() { + if id_to_index.insert(shard.id, index).is_some() { + return Err(format!("manifest repeats shard id {}", shard.id)); + } + for block in &shard.blocks { + if let Some(previous) = block_to_shard.insert(block.clone(), index) { + return Err(format!( + "manifest block {} is owned by shards {} and {}", + block.hex(), + manifest.shards[previous].id, + shard.id + )); + } + } + } + + let mut owned = vec![Vec::new(); manifest.shards.len()]; + let mut owner_old = FxHashMap::default(); + for entry in env.consts.iter() { + let addr = entry.key().clone(); + let constant = entry.value().get().map_err(|error| { + format!("cannot parse environment constant {}: {error}", addr.hex()) + })?; + let block = projection_block(&addr, &constant); + let owner = block_to_shard.get(&block).copied().ok_or_else(|| { + format!( + "environment constant {} (block {}) has no owning manifest shard", + addr.hex(), + block.hex() + ) + })?; + owned[owner].push(addr.clone()); + owner_old.insert(addr, owner); + } + if owner_old.len() != env.consts.len() { + return Err( + "manifest ownership did not cover every environment constant".into(), + ); + } + + let retained_old: Vec = owned + .iter() + .enumerate() + .filter_map(|(index, addresses)| (!addresses.is_empty()).then_some(index)) + .collect(); + if retained_old.is_empty() { + return Err("manifest has no shard owning an environment constant".into()); + } + let retained_ids: FxHashSet = + retained_old.iter().map(|index| manifest.shards[*index].id).collect(); + let source_tree = manifest.tree.clone().unwrap_or_else(|| { + let ids: Vec = manifest.shards.iter().map(|shard| shard.id).collect(); + AggNode::balanced(&ids).expect("a nonempty id list has a balanced tree") + }); + let tree = source_tree + .prune(&|id| retained_ids.contains(&id)) + .ok_or("pruning removed every aggregate-tree leaf")?; + + let mut old_to_retained = FxHashMap::default(); + for (retained, old) in retained_old.iter().copied().enumerate() { + old_to_retained.insert(old, retained); + } + let owner_by_address: FxHashMap = owner_old + .into_iter() + .map(|(address, old)| { + let retained = old_to_retained[&old]; + (address, retained) + }) + .collect(); + + let mut shards = Vec::with_capacity(retained_old.len()); + for (retained, old) in retained_old.iter().copied().enumerate() { + let mut subjects = std::mem::take(&mut owned[old]); + subjects.sort_unstable(); + subjects.dedup(); + let frontier = thin_frontier(env, &subjects); + let subject_tree = SubjectTree::canonical( + subjects, + ShardSet::singleton(retained, retained_old.len()), + )?; + let assumptions = CanonicalTree::from_sorted(frontier)?; + let statement = Statement::new(subject_tree, assumptions); + shards + .push(PreparedShard { original_id: manifest.shards[old].id, statement }); + } + + let mut all_addresses: Vec
= + owner_by_address.keys().cloned().collect(); + all_addresses.sort_unstable(); + let env_root = merkle_root_canonical_sorted(&all_addresses) + .ok_or("cannot aggregate an empty environment")?; + let expected_shards = ShardSet( + (0..retained_old.len().div_ceil(64)) + .map(|word| { + let remaining = retained_old.len().saturating_sub(word * 64); + if remaining >= 64 { u64::MAX } else { (1u64 << remaining) - 1 } + }) + .collect(), + ); + + Ok(PreparedRun { + shards, + owner_by_address, + tree, + env_root, + env_count: all_addresses.len(), + expected_shards, + }) +} + +fn merge_sorted(left: &[Address], right: &[Address]) -> Vec
{ + let mut out = Vec::with_capacity(left.len().saturating_add(right.len())); + let (mut i, mut j) = (0, 0); + while i < left.len() && j < right.len() { + match left[i].cmp(&right[j]) { + Ordering::Less => { + out.push(left[i].clone()); + i += 1; + }, + Ordering::Greater => { + out.push(right[j].clone()); + j += 1; + }, + Ordering::Equal => { + out.push(left[i].clone()); + i += 1; + j += 1; + }, + } + } + out.extend_from_slice(&left[i..]); + out.extend_from_slice(&right[j..]); + out +} + +fn merge_optional_sets( + left: Option<&CanonicalTree>, + right: Option<&CanonicalTree>, +) -> Vec
{ + match (left, right) { + (None, None) => Vec::new(), + (Some(tree), None) | (None, Some(tree)) => tree.leaves.to_vec(), + (Some(left), Some(right)) => merge_sorted(&left.leaves, &right.leaves), + } +} + +fn build_plan( + tree: &AggNode, + shard_by_id: &FxHashMap, + out: &mut Vec, +) -> Result { + match tree { + AggNode::Leaf(id) => { + let shard = shard_by_id.get(id).copied().ok_or_else(|| { + format!("aggregate tree references missing shard {id}") + })?; + let index = out.len(); + out.push(PlanOp::Leaf(shard)); + Ok(index) + }, + AggNode::Internal(left, right) => { + let left_index = build_plan(left, shard_by_id, out)?; + let right_index = build_plan(right, shard_by_id, out)?; + let index = out.len(); + out.push(PlanOp::Join(left_index, right_index)); + Ok(index) + }, + } +} + +fn packed_digest(bytes: &[u8]) -> Vec { + let digest = blake3::hash(bytes); + digest + .as_bytes() + .as_chunks::<4>() + .0 + .iter() + .map(|word| G::from_u32(u32::from_le_bytes(*word))) + .collect() +} + +fn build_claim(fun_idx: usize, input: &[G], output: &[G]) -> Vec { + let mut claim = Vec::with_capacity(2 + input.len() + output.len()); + claim.push(function_channel()); + claim.push(G::from_usize(fun_idx)); + claim.extend_from_slice(input); + claim.extend_from_slice(output); + claim +} + +fn serialize_claims(claims: &[&[G]]) -> Vec { + let mut out = Vec::new(); + out.extend_from_slice(&(claims.len() as u64).to_le_bytes()); + for claim in claims { + out.extend_from_slice(&(claim.len() as u64).to_le_bytes()); + for value in *claim { + out.extend_from_slice(&value.as_canonical_u64().to_le_bytes()); + } + } + out +} + +fn inner_claim(verify_idx: usize, claim_bytes: &[u8]) -> Vec { + build_claim(verify_idx, &packed_digest(claim_bytes), &[]) +} + +fn aggregate_outer_claim( + aggr_idx: usize, + allowed: &[u8], + claim_bytes: &[u8], +) -> Vec { + let mut input = packed_digest(allowed); + input.extend(packed_digest(claim_bytes)); + build_claim(aggr_idx, &input, &[]) +} + +fn allowed_blob( + ixvm_vk: &[u8], + verify_idx: usize, + aggr_vk: &[u8], + aggr_idx: usize, +) -> Vec { + let mut out = Vec::with_capacity(80); + out.extend_from_slice(blake3::hash(ixvm_vk).as_bytes()); + out.extend_from_slice(&(verify_idx as u64).to_le_bytes()); + out.extend_from_slice(blake3::hash(aggr_vk).as_bytes()); + out.extend_from_slice(&(aggr_idx as u64).to_le_bytes()); + out +} + +fn cache_key( + aggr_vk: &[u8], + cache_fri_bytes: &[u8], + outer_claim: &[G], +) -> Address { + let mut bytes = Vec::with_capacity(8 + 32 + cache_fri_bytes.len() + 256); + bytes.extend_from_slice(&CACHE_VERSION.to_le_bytes()); + bytes.extend_from_slice(blake3::hash(aggr_vk).as_bytes()); + bytes.extend_from_slice(cache_fri_bytes); + bytes.extend(serialize_claims(&[outer_claim])); + Address::hash(&bytes) +} + +fn shape_code(left: ChildKind, right: Option) -> u8 { + match right { + None => left.code(), + Some(right) => 2 + 2 * left.code() + right.code(), + } +} + +fn structural_shape_code(left: ChildKind, right: ChildKind) -> u8 { + 6 + 2 * left.code() + right.code() +} + +fn shape_ram_bytes(shape: u8, subject_count: usize) -> usize { + match shape { + 0 | 1 => WRAP_RAM_BYTES, + 3 | 4 | 7 | 8 => MIXED_RAM_BYTES, + 5 => STRUCTURAL_RAM_BYTES + .saturating_add(subject_count.saturating_mul(FLAT_RAM_PER_SUBJECT)), + 9 => STRUCTURAL_RAM_BYTES, + // Shapes 2/6 are direct pairs; unknown shapes retain the conservative + // direct-pair fallback used by the Lean reference scheduler. + _ => DIRECT_RAM_BYTES, + } +} + +fn build_specs( + prepared: &PreparedRun, + verify_idx: usize, + aggr_idx: usize, + structural_above: usize, + direct_joins: bool, + aggr_vk: &[u8], + allowed: &[u8], + cache_fri_bytes: &[u8], +) -> Result, String> { + let shard_by_id: FxHashMap = prepared + .shards + .iter() + .enumerate() + .map(|(index, shard)| (shard.original_id, index)) + .collect(); + let mut ops = Vec::new(); + build_plan(&prepared.tree, &shard_by_id, &mut ops)?; + let raw_leaves = direct_joins && ops.len() > 1; + let mut specs: Vec = Vec::with_capacity(ops.len()); + for op in ops { + match op { + PlanOp::Leaf(shard) => { + let prepared_shard = &prepared.shards[shard]; + let kind = if raw_leaves { ChildKind::Ixvm } else { ChildKind::Aggr }; + let shape = (!raw_leaves).then_some(shape_code(ChildKind::Ixvm, None)); + let outer_claim = if raw_leaves { + inner_claim(verify_idx, &prepared_shard.statement.claim_bytes) + } else { + aggregate_outer_claim( + aggr_idx, + allowed, + &prepared_shard.statement.claim_bytes, + ) + }; + let key = cache_key(aggr_vk, cache_fri_bytes, &outer_claim); + specs.push(SlotSpec { + op, + statement: prepared_shard.statement.clone(), + subject_count: prepared_shard.statement.subjects.count, + structural: false, + kind, + shape, + outer_claim, + cache_key: key, + ram_bytes: shape.map_or(RAW_SHARD_RAM_BYTES, |value| { + shape_ram_bytes(value, prepared_shard.statement.subjects.count) + }), + }); + }, + PlanOp::Join(left_index, right_index) => { + let left = specs + .get(left_index) + .ok_or("aggregate plan has a missing left child")?; + let right = specs + .get(right_index) + .ok_or("aggregate plan has a missing right child")?; + let subject_count = + left.subject_count.saturating_add(right.subject_count); + let structural = subject_count > structural_above; + let shape = if structural { + structural_shape_code(left.kind, right.kind) + } else { + shape_code(left.kind, Some(right.kind)) + }; + let statement = Statement::join( + &left.statement, + &right.statement, + structural, + &prepared.owner_by_address, + )?; + if statement.subjects.count != subject_count { + return Err("aggregate plan has inconsistent subject counts".into()); + } + let outer_claim = + aggregate_outer_claim(aggr_idx, allowed, &statement.claim_bytes); + let key = cache_key(aggr_vk, cache_fri_bytes, &outer_claim); + specs.push(SlotSpec { + op, + statement, + subject_count, + structural, + kind: ChildKind::Aggr, + shape: Some(shape), + outer_claim, + cache_key: key, + ram_bytes: shape_ram_bytes(shape, subject_count), + }); + }, + } + } + Ok(specs) +} + +fn store_path(root: &Path, address: &Address) -> PathBuf { + let hex = address.hex(); + root.join(&hex[0..2]).join(&hex[2..4]).join(&hex[4..6]).join(&hex[6..]) +} + +fn read_store(root: &Path, address: &Address) -> Result, String> { + let path = store_path(root, address); + fs::read(&path).map_err(|error| format!("read {}: {error}", path.display())) +} + +fn write_store(root: &Path, bytes: &[u8]) -> Result { + let address = Address::hash(bytes); + let path = store_path(root, &address); + let parent = path.parent().ok_or("store path has no parent")?; + fs::create_dir_all(parent) + .map_err(|error| format!("create {}: {error}", parent.display()))?; + fs::write(&path, bytes) + .map_err(|error| format!("write {}: {error}", path.display()))?; + Ok(address) +} + +fn decode_wrapper(bytes: &[u8]) -> Result { + let mut cursor = bytes; + let proof = IxonProof::get(&mut cursor)?; + if !cursor.is_empty() { + return Err(format!("{} trailing bytes after proof wrapper", cursor.len())); + } + Ok(proof) +} + +fn load_input_proofs( + proof_hexes: &str, + store_dir: &Path, + prepared: &[PreparedShard], +) -> Result>, String> { + let values: Vec<&str> = + proof_hexes.lines().filter(|line| !line.is_empty()).collect(); + if values.len() != prepared.len() { + return Err(format!( + "aggregate requires exactly {} shard proofs; got {}", + prepared.len(), + values.len() + )); + } + let by_digest: FxHashMap = prepared + .iter() + .enumerate() + .map(|(index, shard)| (Address::hash(&shard.statement.claim_bytes), index)) + .collect(); + if by_digest.len() != prepared.len() { + return Err("two reconstructed shard claims have the same digest".into()); + } + let mut proofs: Vec>> = vec![None; prepared.len()]; + for value in values { + let address = Address::from_hex(value).ok_or_else(|| { + format!("shard proof is not a 64-character address: {value}") + })?; + let bytes = read_store(store_dir, &address)?; + if Address::hash(&bytes) != address { + return Err(format!( + "shard proof store object {} has the wrong digest", + address.hex() + )); + } + let wrapper = decode_wrapper(&bytes).map_err(|error| { + format!("decode shard proof {}: {error}", address.hex()) + })?; + let mut claim_bytes = Vec::new(); + wrapper.claim.put(&mut claim_bytes); + let digest = Address::hash(&claim_bytes); + let shard = by_digest.get(&digest).copied().ok_or_else(|| { + format!("proof {} matches no manifest shard", address.hex()) + })?; + if wrapper.claim != prepared[shard].statement.claim { + return Err(format!( + "proof {} hit a claim-digest collision for shard {}", + address.hex(), + prepared[shard].original_id + )); + } + if proofs[shard].is_some() { + return Err(format!( + "more than one proof supplied for shard {}", + prepared[shard].original_id + )); + } + proofs[shard] = Some(Arc::new(wrapper)); + } + proofs + .into_iter() + .enumerate() + .map(|(index, proof)| { + proof.ok_or_else(|| { + format!("no proof supplied for shard {}", prepared[index].original_id) + }) + }) + .collect() +} + +fn cache_address(cache_dir: &Path, key: &Address) -> Option
{ + let path = cache_dir.join(key.hex()); + let raw = fs::read_to_string(path).ok()?; + Address::from_hex(raw.trim()) +} + +fn load_cached( + ctx: ProveContext<'_>, + slot_index: usize, + spec: &SlotSpec, +) -> Option<(AiurProof, Address)> { + let cache_dir = ctx.cache_dir?; + let address = cache_address(cache_dir, &spec.cache_key)?; + let reject = |reason: &str| { + eprintln!( + "[aggregate] slot {slot_index}: cache miss (wrapper {} rejected: {reason})", + address.hex() + ); + }; + let bytes = match read_store(ctx.store_dir, &address) { + Ok(bytes) => bytes, + Err(error) => { + reject(&error); + return None; + }, + }; + if Address::hash(&bytes) != address { + reject("store object has a different content digest"); + return None; + } + let wrapper = match decode_wrapper(&bytes) { + Ok(wrapper) => wrapper, + Err(error) => { + reject(&error); + return None; + }, + }; + if wrapper.claim != spec.statement.claim { + reject("bundled claim does not match the expected statement"); + return None; + } + let proof = match AiurProof::from_bytes(&wrapper.proof) { + Ok(proof) => proof, + Err(error) => { + reject(&format!("proof deserialization failed: {error}")); + return None; + }, + }; + if let Err(error) = ctx.aggr_system.verify(&spec.outer_claim, &proof) { + reject(&format!("native verification failed: {error:?}")); + return None; + } + eprintln!("[aggregate] slot {slot_index}: cache hit {}", address.hex()); + Some((proof, address)) +} + +fn persist_wrapper( + store_dir: &Path, + statement: &Statement, + proof: &AiurProof, +) -> Result { + write_store(store_dir, &statement.claim_bytes)?; + let proof_bytes = proof.to_bytes().map_err(|error| { + format!("aggregate proof serialization failed: {error}") + })?; + let wrapper = IxonProof::new(statement.claim.clone(), proof_bytes); + let mut bytes = Vec::new(); + wrapper.put(&mut bytes); + write_store(store_dir, &bytes) +} + +fn persist_cached( + ctx: ProveContext<'_>, + slot_index: usize, + spec: &SlotSpec, + proof: &AiurProof, +) -> Option
{ + let cache_dir = ctx.cache_dir?; + match (|| -> Result { + let address = persist_wrapper(ctx.store_dir, &spec.statement, proof)?; + fs::create_dir_all(cache_dir).map_err(|error| { + format!("create aggregate cache {}: {error}", cache_dir.display()) + })?; + let destination = cache_dir.join(spec.cache_key.hex()); + let temporary = cache_dir.join(format!( + "{}.tmp.{}.{}", + spec.cache_key.hex(), + std::process::id(), + slot_index + )); + fs::write(&temporary, format!("{}\n", address.hex())).map_err(|error| { + format!("write cache index {}: {error}", temporary.display()) + })?; + fs::rename(&temporary, &destination).map_err(|error| { + format!( + "publish cache index {} -> {}: {error}", + temporary.display(), + destination.display() + ) + })?; + Ok(address) + })() { + Ok(address) => { + eprintln!( + "[aggregate] slot {slot_index}: cached proof {}", + address.hex() + ); + Some(address) + }, + Err(error) => { + eprintln!( + "[aggregate] slot {slot_index}: warning: could not persist cache entry: {error}" + ); + None + }, + } +} + +struct OwnedTreeAdvice { + root: [u8; 32], + bytes: Vec, +} + +fn push_canonical_tree(out: &mut Vec, tree: &CanonicalTree) { + out.push(OwnedTreeAdvice { + root: *tree.root.as_bytes(), + bytes: tree.serialized().to_vec(), + }); +} + +fn path_payload(path: Option<&MerklePath>) -> Result, String> { + let Some(path) = path else { + return Ok(vec![0]); + }; + let length = u8::try_from(path.len()).map_err(|_overflow| { + format!("aggregate Merkle path has {} steps", path.len()) + })?; + if length > 64 { + return Err(format!( + "aggregate Merkle path has {length} steps (maximum 64)" + )); + } + let mut out = Vec::with_capacity(2 + path.len() * 33); + out.extend([1, length]); + for (sibling, is_left) in path { + out.push(if *is_left { 0 } else { 1 }); + out.extend_from_slice(sibling.as_bytes()); + } + Ok(out) +} + +fn tree_advice( + left: &Statement, + right: &Statement, + output: &Statement, + structural: bool, +) -> Result, String> { + let mut trees = Vec::new(); + if !structural { + let left_subjects = left + .subjects + .canonical_tree() + .ok_or("flat join has structural left subjects")?; + push_canonical_tree(&mut trees, left_subjects); + } + if let Some(tree) = &left.assumptions { + push_canonical_tree(&mut trees, tree); + } + if !structural { + let right_subjects = right + .subjects + .canonical_tree() + .ok_or("flat join has structural right subjects")?; + push_canonical_tree(&mut trees, right_subjects); + } + if let Some(tree) = &right.assumptions { + push_canonical_tree(&mut trees, tree); + } + if !structural { + let output_subjects = output + .subjects + .canonical_tree() + .ok_or("flat join produced structural subjects")?; + push_canonical_tree(&mut trees, output_subjects); + } + if let Some(tree) = &output.assumptions { + push_canonical_tree(&mut trees, tree); + } + Ok(trees) +} + +fn structural_path_advice( + left: &Statement, + right: &Statement, + output: &Statement, + owner_by_address: &FxHashMap, +) -> Result)>, String> { + let candidates = merge_optional_sets( + left.assumptions.as_deref(), + right.assumptions.as_deref(), + ); + let mut paths = Vec::with_capacity(candidates.len()); + for candidate in candidates { + let owner = owner_by_address.get(&candidate).ok_or_else(|| { + format!("aggregate assumption {} has no owning shard", candidate.hex()) + })?; + let path = output.subjects.merkle_proof(&candidate, *owner); + paths.push((candidate, path_payload(path.as_ref())?)); + } + Ok(paths) +} + +fn prove_aggregate( + ctx: ProveContext<'_>, + spec: &SlotSpec, + left: &Slot, + right: Option<&Slot>, + slot_index: usize, +) -> Result<(AiurProof, Option
), String> { + if let Some((proof, address)) = load_cached(ctx, slot_index, spec) { + return Ok((proof, Some(address))); + } + + let left_system = match left.kind { + ChildKind::Ixvm => ctx.ixvm_system, + ChildKind::Aggr => ctx.aggr_system, + }; + let left_advice = left_system + .proof_to_advice_bytes(&left.outer_claim, &left.proof) + .map_err(|error| format!("left child proof advice failed: {error:?}"))?; + let right_advice = if let Some(right) = right { + let system = match right.kind { + ChildKind::Ixvm => ctx.ixvm_system, + ChildKind::Aggr => ctx.aggr_system, + }; + system + .proof_to_advice_bytes(&right.outer_claim, &right.proof) + .map_err(|error| format!("right child proof advice failed: {error:?}"))? + } else { + Vec::new() + }; + + let mut preimage_storage = Vec::new(); + if let Some(right) = right { + preimage_storage.push(( + *blake3::hash(&left.statement.claim_bytes).as_bytes(), + left.statement.claim_bytes.as_slice(), + )); + preimage_storage.push(( + *blake3::hash(&right.statement.claim_bytes).as_bytes(), + right.statement.claim_bytes.as_slice(), + )); + } + let preimages: Vec> = preimage_storage + .iter() + .map(|(digest, bytes)| AggrPreimage { digest: *digest, bytes }) + .collect(); + + let (tree_storage, path_storage) = if let Some(right) = right { + ( + tree_advice( + &left.statement, + &right.statement, + &spec.statement, + spec.structural, + )?, + if spec.structural { + structural_path_advice( + &left.statement, + &right.statement, + &spec.statement, + ctx.owner_by_address, + )? + } else { + Vec::new() + }, + ) + } else { + (Vec::new(), Vec::new()) + }; + let trees: Vec> = tree_storage + .iter() + .map(|tree| AggrTree { root: tree.root, bytes: &tree.bytes }) + .collect(); + let paths: Vec> = path_storage + .iter() + .map(|(candidate, bytes)| AggrPath { + candidate: *candidate.as_bytes(), + bytes, + }) + .collect(); + let empty = Vec::new(); + let right_claims = + right.map_or(empty.as_slice(), |slot| slot.claims_bytes.as_slice()); + let shape = spec.shape.ok_or("aggregate proof slot has no shape")?; + let mut io = aggr_io_buffer(&AggrAdvice { + shape, + proof_advice: [&left_advice, &right_advice], + ixvm_vk: ctx.ixvm_vk, + self_vk: ctx.aggr_vk, + child_claims: [&left.claims_bytes, right_claims], + output_claim: &spec.statement.claim_bytes, + allowed: ctx.allowed, + preimages: &preimages, + trees: &trees, + paths: &paths, + }); + let mut public_input = packed_digest(ctx.allowed); + public_input.extend(packed_digest(&spec.statement.claim_bytes)); + let (outer_claim, proof) = ctx.aggr_system.prove_ixvm( + ctx.aggr_idx, + &public_input, + &mut io, + execute_ix_aggr, + ); + if outer_claim != spec.outer_claim { + return Err("aggregate prover returned an unexpected outer claim".into()); + } + let address = persist_cached(ctx, slot_index, spec, &proof); + Ok((proof, address)) +} + +fn prove_slot( + ctx: ProveContext<'_>, + slot_index: usize, + children: &[Arc], +) -> Result, String> { + let spec = ctx.specs.get(slot_index).ok_or("missing aggregate slot spec")?; + match spec.op { + PlanOp::Leaf(shard) => { + let prepared = &ctx.prepared[shard]; + let wrapper = &ctx.proofs[shard]; + let proof = AiurProof::from_bytes(&wrapper.proof).map_err(|error| { + format!("shard {} proof does not decode: {error}", prepared.original_id) + })?; + let inner = inner_claim(ctx.verify_idx, &prepared.statement.claim_bytes); + ctx.ixvm_system.verify(&inner, &proof).map_err(|error| { + format!( + "shard {} proof fails native verification: {error:?}", + prepared.original_id + ) + })?; + let inner_claims = serialize_claims(&[&inner]); + if spec.kind == ChildKind::Ixvm { + if spec.outer_claim != inner { + return Err("direct shard slot has an unexpected outer claim".into()); + } + return Ok(Arc::new(Slot { + kind: ChildKind::Ixvm, + statement: spec.statement.clone(), + outer_claim: inner, + proof, + proof_address: None, + claims_bytes: inner_claims, + })); + } + eprintln!( + "[aggregate] wrapping shard {} into slot {slot_index}", + prepared.original_id + ); + let raw = Slot { + kind: ChildKind::Ixvm, + statement: spec.statement.clone(), + outer_claim: inner, + proof, + proof_address: None, + claims_bytes: inner_claims, + }; + let (proof, proof_address) = + prove_aggregate(ctx, spec, &raw, None, slot_index)?; + Ok(Arc::new(Slot { + kind: ChildKind::Aggr, + statement: spec.statement.clone(), + outer_claim: spec.outer_claim.clone(), + proof, + proof_address, + claims_bytes: serialize_claims(&[&spec.outer_claim]), + })) + }, + PlanOp::Join(left_index, right_index) => { + if children.len() != 2 { + return Err("aggregate join did not receive two children".into()); + } + let left = &children[0]; + let right = &children[1]; + let mode = if spec.structural { "structural" } else { "flat" }; + eprintln!( + "[aggregate] {mode}-joining slots {left_index}, {right_index} into {slot_index}" + ); + let (proof, proof_address) = + prove_aggregate(ctx, spec, left, Some(right), slot_index)?; + Ok(Arc::new(Slot { + kind: ChildKind::Aggr, + statement: spec.statement.clone(), + outer_claim: spec.outer_claim.clone(), + proof, + proof_address, + claims_bytes: serialize_claims(&[&spec.outer_claim]), + })) + }, + } +} + +fn dependencies_complete(spec: &SlotSpec, completed: &[bool]) -> bool { + match spec.op { + PlanOp::Leaf(_) => true, + PlanOp::Join(left, right) => completed[left] && completed[right], + } +} + +fn run_scheduler( + ctx: ProveContext<'_>, + jobs: usize, + budget: usize, +) -> Result>, String> { + if budget == 0 { + return Err("aggregate scheduler RAM budget must be positive".into()); + } + let max_jobs = if jobs == 0 { ctx.specs.len().max(1) } else { jobs.max(1) }; + let (sender, receiver) = mpsc::channel(); + thread::scope(|scope| -> Result>, String> { + let mut slots: Vec>> = vec![None; ctx.specs.len()]; + let mut completed = vec![false; ctx.specs.len()]; + let mut in_flight = vec![false; ctx.specs.len()]; + let mut completed_count = 0usize; + let mut active = 0usize; + let mut reserved = 0usize; + let mut failures: Vec<(usize, String)> = Vec::new(); + + while completed_count < ctx.specs.len() { + if failures.is_empty() && active < max_jobs { + let mut ready: Vec = ctx + .specs + .iter() + .enumerate() + .filter_map(|(index, spec)| { + (!completed[index] + && !in_flight[index] + && dependencies_complete(spec, &completed)) + .then_some(index) + }) + .collect(); + ready.sort_unstable_by(|left, right| { + ctx.specs[*right] + .ram_bytes + .cmp(&ctx.specs[*left].ram_bytes) + .then_with(|| left.cmp(right)) + }); + for index in ready { + if active >= max_jobs { + break; + } + let weight = ctx.specs[index].ram_bytes; + let fits = reserved.saturating_add(weight) <= budget; + if !fits && active != 0 { + continue; + } + let children = match ctx.specs[index].op { + PlanOp::Leaf(_) => Vec::new(), + PlanOp::Join(left, right) => vec![ + slots[left].as_ref().expect("completed left slot").clone(), + slots[right].as_ref().expect("completed right slot").clone(), + ], + }; + in_flight[index] = true; + active += 1; + reserved = reserved.saturating_add(weight); + let over = + if weight > budget { "; over-budget slot runs alone" } else { "" }; + eprintln!( + "[aggregate] slot {index}: admitted {} GiB; reserved {}/{} GiB; active {active}/{max_jobs}{over}", + format_gib(weight), + format_gib(reserved), + format_gib(budget), + ); + let sender = sender.clone(); + scope.spawn(move || { + let result = + std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + prove_slot(ctx, index, &children) + })) + .unwrap_or_else(|payload| { + Err(format!( + "Rust proof worker panicked: {}", + panic_text(&payload) + )) + }); + let _ = sender.send((index, weight, result)); + }); + } + } + + if active == 0 { + if failures.is_empty() { + failures + .push((ctx.specs.len(), "aggregate scheduler deadlocked".into())); + } + break; + } + + let (index, weight, result) = receiver.recv().map_err(|error| { + format!("aggregate scheduler channel closed: {error}") + })?; + if !in_flight.get(index).copied().unwrap_or(false) { + failures.push((index, "duplicate or unknown scheduler result".into())); + continue; + } + in_flight[index] = false; + active -= 1; + reserved = reserved.saturating_sub(weight); + match result { + Ok(slot) => { + slots[index] = Some(slot); + completed[index] = true; + completed_count += 1; + }, + Err(error) => failures.push((index, error)), + } + } + + while active > 0 { + let (index, weight, result) = receiver.recv().map_err(|error| { + format!("aggregate scheduler drain failed: {error}") + })?; + if in_flight.get(index).copied().unwrap_or(false) { + in_flight[index] = false; + active -= 1; + reserved = reserved.saturating_sub(weight); + } + match result { + Ok(slot) => { + slots[index] = Some(slot); + completed[index] = true; + }, + Err(error) => failures.push((index, error)), + } + } + if !failures.is_empty() { + failures.sort_unstable_by_key(|(index, _)| *index); + let (index, error) = failures.remove(0); + return Err(if index < ctx.specs.len() { + format!("slot {index}: {error}") + } else { + error + }); + } + slots + .into_iter() + .enumerate() + .map(|(index, slot)| { + slot.ok_or_else(|| format!("scheduler completed without slot {index}")) + }) + .collect() + }) +} + +fn print_plan( + specs: &[SlotSpec], + prepared: &[PreparedShard], + threshold: usize, +) { + let leaves = + specs.iter().filter(|spec| matches!(spec.op, PlanOp::Leaf(_))).count(); + let wraps = specs + .iter() + .filter(|spec| { + matches!(spec.op, PlanOp::Leaf(_)) && spec.kind == ChildKind::Aggr + }) + .count(); + let structural = specs.iter().filter(|spec| spec.structural).count(); + let policy = if wraps == leaves { + format!("{wraps} wraps") + } else { + format!("{} direct IxVM leaves", leaves - wraps) + }; + eprintln!( + "[aggregate] plan: {policy} + {} binary joins ({structural} structural; threshold > {threshold} subject leaves)", + specs.len() - leaves + ); + for (index, spec) in specs.iter().enumerate() { + match spec.op { + PlanOp::Leaf(shard) => { + let mode = + if spec.kind == ChildKind::Ixvm { "raw shard" } else { "wrap shard" }; + eprintln!( + " slot {index}: {mode} {} ({} subjects)", + prepared[shard].original_id, spec.subject_count + ); + }, + PlanOp::Join(left, right) => { + let mode = if spec.structural { "structural" } else { "flat" }; + eprintln!( + " slot {index}: {mode} shape {} slots {left}, {right} ({} subjects)", + spec.shape.unwrap_or(u8::MAX), + spec.subject_count + ); + }, + } + } +} + +fn run(config: RunConfig<'_>) -> Result { + if config.cache_fri_bytes.len() != 40 { + return Err(format!( + "aggregate cache FRI serialization is {} bytes, expected 40", + config.cache_fri_bytes.len() + )); + } + let started = Instant::now(); + let manifest_bytes = fs::read(config.manifest_path).map_err(|error| { + format!("read manifest {}: {error}", config.manifest_path.display()) + })?; + let manifest = ShardManifest::from_bytes(&manifest_bytes) + .map_err(|error| format!("manifest parse failed: {error}"))?; + let parsed_at = Instant::now(); + let prepared = prepare_run(&config.env_handle.env, &manifest)?; + let prepared_at = Instant::now(); + + let ixvm_vk = aiur::vk_codec::aiur_system_to_bytes(config.ixvm_system) + .map_err(|error| format!("IxVM VK serialization failed: {error}"))?; + let aggr_vk = aiur::vk_codec::aiur_system_to_bytes(config.aggr_system) + .map_err(|error| format!("ixAggr VK serialization failed: {error}"))?; + let allowed = + allowed_blob(&ixvm_vk, config.verify_idx, &aggr_vk, config.aggr_idx); + let specs = build_specs( + &prepared, + config.verify_idx, + config.aggr_idx, + config.structural_above, + config.direct_joins, + &aggr_vk, + &allowed, + config.cache_fri_bytes, + )?; + let specs_at = Instant::now(); + print_plan(&specs, &prepared.shards, config.structural_above); + if config.plan_only { + eprintln!( + "[aggregate] Rust plan startup: manifest {:.3}s, env/claims {:.3}s, plan/statements {:.3}s; total {:.3}s", + (parsed_at - started).as_secs_f64(), + (prepared_at - parsed_at).as_secs_f64(), + (specs_at - prepared_at).as_secs_f64(), + (specs_at - started).as_secs_f64(), + ); + return Ok(String::new()); + } + + let home = std::env::var_os("HOME").ok_or("no HOME environment variable")?; + let ix_root = PathBuf::from(home).join(".ix"); + let store_dir = ix_root.join("store"); + let cache_path = ix_root.join("cache").join("aggregate"); + let cache_dir = config.use_cache.then_some(cache_path.as_path()); + if let Some(dir) = cache_dir { + fs::create_dir_all(dir).map_err(|error| { + format!("create aggregate cache {}: {error}", dir.display()) + })?; + } else { + eprintln!("[aggregate] cache disabled (--no-cache)"); + } + let proofs = + load_input_proofs(config.proof_hexes, &store_dir, &prepared.shards)?; + let proofs_at = Instant::now(); + eprintln!( + "[aggregate] Rust startup: manifest {:.3}s, env/claims {:.3}s, plan/statements {:.3}s, proofs {:.3}s; total {:.3}s", + (parsed_at - started).as_secs_f64(), + (prepared_at - parsed_at).as_secs_f64(), + (specs_at - prepared_at).as_secs_f64(), + (proofs_at - specs_at).as_secs_f64(), + (proofs_at - started).as_secs_f64(), + ); + let jobs_label = if config.jobs == 0 { + "all ready slots".to_string() + } else { + config.jobs.to_string() + }; + eprintln!( + "[aggregate] scheduler: jobs={jobs_label}, RAM budget {} GiB; wrap/self 195.0 GiB, direct 390.0 GiB, mixed 340.0 GiB, flat +1 MiB/subject", + format_gib(config.ram_budget_bytes) + ); + + let context = ProveContext { + specs: &specs, + prepared: &prepared.shards, + proofs: &proofs, + owner_by_address: &prepared.owner_by_address, + ixvm_system: config.ixvm_system, + aggr_system: config.aggr_system, + ixvm_vk: &ixvm_vk, + aggr_vk: &aggr_vk, + allowed: &allowed, + verify_idx: config.verify_idx, + aggr_idx: config.aggr_idx, + store_dir: &store_dir, + cache_dir, + }; + let slots = run_scheduler(context, config.jobs, config.ram_budget_bytes)?; + let root = slots.last().ok_or("aggregate plan produced no root slot")?; + if root.kind != ChildKind::Aggr { + return Err("aggregate plan produced a raw IxVM root".into()); + } + if root.statement.subjects.count != prepared.env_count { + return Err(format!( + "aggregate root has {} subjects, environment has {}", + root.statement.subjects.count, prepared.env_count + )); + } + if root.statement.subjects.shards != prepared.expected_shards { + return Err("aggregate root does not contain every retained shard".into()); + } + let mut root_leaves = Vec::with_capacity(prepared.env_count); + root.statement.subjects.collect_leaves(&mut root_leaves); + root_leaves.sort_unstable(); + root_leaves.dedup(); + let canonical_root = merkle_root_canonical_sorted(&root_leaves) + .ok_or("aggregate root has no subject leaves")?; + if canonical_root != prepared.env_root { + return Err(format!( + "aggregate root subjects canonicalize to {}, not environment root {}", + canonical_root.hex(), + prepared.env_root.hex() + )); + } + if root.statement.assumptions.is_some() { + return Err("aggregate root retains undischarged assumptions".into()); + } + config.aggr_system.verify(&root.outer_claim, &root.proof).map_err( + |error| format!("aggregate root proof failed verification: {error:?}"), + )?; + let address = match &root.proof_address { + Some(address) => address.clone(), + None => persist_wrapper(&store_dir, &root.statement, &root.proof)?, + }; + eprintln!("[aggregate] root proof: {}", address.hex()); + Ok(address.hex()) +} + +fn panic_text(payload: &Box) -> &str { + payload + .downcast_ref::<&str>() + .copied() + .or_else(|| payload.downcast_ref::().map(String::as_str)) + .unwrap_or("unknown Rust panic") +} + +/// Production FFI called once after Lean has compiled the IxVM and ixAggr +/// systems. Proof addresses are newline-separated to keep the ABI flat. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_stage2_aggregate( + ixvm_system: LeanExternal>, + aggr_system: LeanExternal>, + env_handle: LeanExternal>, + manifest_path: LeanString>, + proof_hexes: LeanString>, + verify_idx: LeanNat>, + aggr_idx: LeanNat>, + jobs: LeanNat>, + ram_budget_bytes: LeanNat>, + structural_above: LeanNat>, + direct_joins: bool, + plan_only: bool, + cache_fri_bytes: LeanByteArray>, + use_cache: bool, +) -> LeanExcept { + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + run(RunConfig { + ixvm_system: ixvm_system.get(), + aggr_system: aggr_system.get(), + env_handle: env_handle.get(), + manifest_path: Path::new(manifest_path.as_str()), + proof_hexes: proof_hexes.as_str(), + verify_idx: lean_unbox_nat_as_usize(verify_idx.inner()), + aggr_idx: lean_unbox_nat_as_usize(aggr_idx.inner()), + jobs: lean_unbox_nat_as_usize(jobs.inner()), + ram_budget_bytes: lean_unbox_nat_as_usize(ram_budget_bytes.inner()), + structural_above: lean_unbox_nat_as_usize(structural_above.inner()), + direct_joins, + plan_only, + cache_fri_bytes: cache_fri_bytes.as_bytes(), + use_cache, + }) + })); + match result { + Ok(Ok(address)) => LeanExcept::ok(LeanString::new(&address)), + Ok(Err(error)) => LeanExcept::error_string(&error), + Err(payload) => LeanExcept::error_string(&format!( + "native Stage 2 orchestration panicked: {}", + panic_text(&payload) + )), + } +} + +#[cfg(test)] +mod tests { + use super::*; + use ix_kernel::shard::ShardInfo; + use ixon::{Axiom, Expr}; + + fn addr(label: &str) -> Address { + Address::hash(label.as_bytes()) + } + + #[test] + fn sorted_merge_is_a_set_union() { + let a = addr("a"); + let b = addr("b"); + let c = addr("c"); + let mut left = vec![a.clone(), c.clone()]; + let mut right = vec![b.clone(), c.clone()]; + left.sort_unstable(); + right.sort_unstable(); + let merged = merge_sorted(&left, &right); + assert_eq!(merged.len(), 3); + assert!(merged.windows(2).all(|window| window[0] < window[1])); + } + + #[test] + fn cached_canonical_path_matches_root() { + let mut leaves: Vec
= + (0..17).map(|index| addr(&format!("leaf-{index}"))).collect(); + leaves.sort_unstable(); + let tree = CanonicalTree::from_sorted(leaves.clone()).unwrap().unwrap(); + for leaf in leaves { + let path = tree.merkle_proof(&leaf).expect("member path"); + assert!(ixon::merkle::verify_merkle_proof(&tree.root, &leaf, &path)); + } + } + + #[test] + fn structural_path_uses_cached_child_roots() { + let mut left_leaves = vec![addr("a"), addr("b")]; + let mut right_leaves = vec![addr("c"), addr("d")]; + left_leaves.sort_unstable(); + right_leaves.sort_unstable(); + let left = + SubjectTree::canonical(left_leaves.clone(), ShardSet::singleton(0, 2)) + .unwrap(); + let right = + SubjectTree::canonical(right_leaves.clone(), ShardSet::singleton(1, 2)) + .unwrap(); + let joined = SubjectTree::structural(left, right); + for leaf in left_leaves.iter().chain(&right_leaves) { + let owner = usize::from(right_leaves.contains(leaf)); + let path = joined.merkle_proof(leaf, owner).expect("member path"); + assert!(ixon::merkle::verify_merkle_proof(&joined.root, leaf, &path)); + } + } + + #[test] + fn cache_key_has_a_stable_test_vector() { + let claim = vec![G::from_u64(1), G::from_u64(2), G::from_u64(3)]; + let key = cache_key(b"vk", &[7; 40], &claim); + assert_eq!( + key.hex(), + "86ed059157e2915fe0a83f1afd58f31f7553659ad778669f6b795e1473e7afe0" + ); + } + + fn store_axiom( + env: &ixon::Env, + typ: Arc, + refs: Vec
, + ) -> Address { + let constant = Constant { + info: ConstantInfo::Axio(Axiom { is_unsafe: false, lvls: 0, typ }), + sharing: Vec::new(), + refs, + univs: Vec::new(), + }; + let mut bytes = Vec::new(); + constant.put(&mut bytes); + let address = Address::hash(&bytes); + env.store_const(address.clone(), constant); + address + } + + fn shard(id: u32, block: Address) -> ShardInfo { + ShardInfo { + id, + blocks: vec![block], + heartbeats: 0, + own_size: 0, + foreign_blocks: Vec::new(), + cross_ingress: 0, + assumption_root: None, + measured_peak_bytes: 0, + } + } + + #[test] + fn native_preparation_and_structural_fold_discharge_a_frontier() { + let env = ixon::Env::new(); + let dependency = store_axiom(&env, Expr::sort(0), Vec::new()); + let consumer = store_axiom( + &env, + Expr::reference(0, Vec::new()), + vec![dependency.clone()], + ); + let manifest = ShardManifest { + num_shards: 2, + shards: vec![shard(0, consumer), shard(1, dependency.clone())], + total_cross_ingress: 0, + tree: Some(AggNode::Internal( + Box::new(AggNode::Leaf(0)), + Box::new(AggNode::Leaf(1)), + )), + }; + let prepared = prepare_run(&env, &manifest).expect("native preparation"); + let specs = build_specs( + &prepared, + 3, + 5, + 0, + false, + b"aggregate-vk", + b"allowed", + &[0; 40], + ) + .expect("native specs"); + assert_eq!(specs.len(), 3); + assert!(specs[2].structural); + assert_eq!(specs[2].subject_count, 2); + assert!(specs[2].statement.assumptions.is_none()); + let paths = structural_path_advice( + &specs[0].statement, + &specs[1].statement, + &specs[2].statement, + &prepared.owner_by_address, + ) + .expect("structural paths"); + assert_eq!(paths.len(), 1); + assert_eq!(paths[0].0, dependency); + assert_eq!(paths[0].1.first(), Some(&1)); + } +} From e6f50a13dd92bc9f93354ecdb2892ad941861345 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Thu, 3 Sep 2026 04:37:40 -0400 Subject: [PATCH 38/44] Add targeted Stage 2 replay --- Ix/Aiur/Protocol.lean | 11 +- Ix/Cli/AggregateCmd.lean | 19 +- Tests/AggrSemantics.lean | 4 +- crates/ffi/src/aiur/aggregate.rs | 331 +++++++++++++++++++++++++++---- 4 files changed, 319 insertions(+), 46 deletions(-) diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 543861de7..a3442a9a1 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -201,14 +201,17 @@ has compiled the IxVM and `ix_aggr` systems. Rust owns all data-dependent orchestration: manifest/environment binding, shard-claim reconstruction, statement folding, cache validation, dependency scheduling, recursive advice, proving, and persistence. `proofHexes` is one store address per line; -`cacheFriBytes` is the stable 40-byte recursion-FRI cache identity. Returns the -persisted root proof address. -/ +`cacheFriBytes` is the stable 40-byte recursion-FRI cache identity. +`reproveSlotCode` is zero for a full run and `slot + 1` for a targeted replay; +the latter loads and verifies only the target's immediate cached children. +When `writeOutputs` is false, proofs are hashed but neither the store nor cache +is changed. Returns the root or replayed proof address. -/ @[extern "rs_aiur_stage2_aggregate"] opaque aggregateStage2 (ixvmSystem aggrSystem : @& AiurSystem) (envHandle : @& EnvHandle) (manifestPath proofHexes : @& String) - (verifyIdx aggrIdx jobs ramBudgetBytes structuralAbove : @& Nat) + (verifyIdx aggrIdx jobs ramBudgetBytes structuralAbove reproveSlotCode : @& Nat) (directJoins planOnly : Bool) (cacheFriBytes : @& ByteArray) - (useCache : Bool) : + (useCache writeOutputs : Bool) : Except String String @[extern "rs_aiur_system_prove_addr_with_env"] diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean index e081ac716..0e943151b 100644 --- a/Ix/Cli/AggregateCmd.lean +++ b/Ix/Cli/AggregateCmd.lean @@ -928,6 +928,14 @@ private def runAggregateCmdNativeWith let jobs := ((p.flag? "jobs").map (·.as! Nat)).getD 0 let structuralAbove := ((p.flag? "structural-above").map (·.as! Nat)).getD defaultStructuralAbove + let reproveSlot? := (p.flag? "reprove-slot").map (·.as! Nat) + if reproveSlot?.isSome && p.hasFlag "plan-only" then + IO.eprintln "error: --reprove-slot cannot be combined with --plan-only" + return 1 + if reproveSlot?.isSome && p.hasFlag "no-cache" then + IO.eprintln "error: --reprove-slot requires aggregate cache reads" + return 1 + let reproveSlotCode := reproveSlot?.map (· + 1) |>.getD 0 let proofHexes := String.intercalate "\n" (p.variableArgsAs! String).toList @@ -965,9 +973,10 @@ private def runAggregateCmdNativeWith let nativeResult ← IO.lazyPure fun _ => ixvmBackend.system.aggregateStage2 aggrBackend.system envHandle manifestPath proofHexes verifyIdx aggrIdx jobs ramBudgetBytes - structuralAbove (p.hasFlag "direct-joins") + structuralAbove reproveSlotCode (p.hasFlag "direct-joins") (p.hasFlag "plan-only") - recursionParameters.cacheFriBytes !(p.hasFlag "no-cache") + recursionParameters.cacheFriBytes (!(p.hasFlag "no-cache")) + (!(p.hasFlag "no-write")) match nativeResult with | .error e => IO.eprintln s!"aggregate failed: {e}"; return 1 | .ok _ => return 0 @@ -1192,14 +1201,16 @@ def aggregateCmd : Cli.Cmd := `[Cli| "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." + "no-cache"; "Bypass aggregate cache reads and intermediate cache writes; the root wrapper is still persisted unless --no-write." + "no-write"; "Do not change the proof store or aggregate cache; useful with --reprove-slot for a read-only spot check." + "reprove-slot" : Nat; "Recompute exactly Stage 2 slot N from verified cached immediate children, bypassing that slot's cache entry." "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)." + ...proofs : String; "Persisted shard-proof wrapper addresses, in any order (one per nonempty shard, except --plan-only or replay with aggregate children)." ] end diff --git a/Tests/AggrSemantics.lean b/Tests/AggrSemantics.lean index 752b1e73f..285bbcbfc 100644 --- a/Tests/AggrSemantics.lean +++ b/Tests/AggrSemantics.lean @@ -347,8 +347,8 @@ def semanticSuite : IO UInt32 := do | .ok handle => pure <| (ixvmSystem.aggregateStage2 selfSystem handle ixesPath.toString "" verifyIdx fakeAggrIdx 1 - (16 * 1024 * 1024 * 1024) 4096 false true - childRecursionParameters.cacheFriBytes false).isOk + (16 * 1024 * 1024 * 1024) 4096 0 false true + childRecursionParameters.cacheFriBytes false true).isOk let (pairEnv, pairLeft, pairRight) := pairIxonEnv let pairManifest := Ix.Cli.CheckCmd.parseIxesManifest diff --git a/crates/ffi/src/aiur/aggregate.rs b/crates/ffi/src/aiur/aggregate.rs index 1406af97a..fd9036ecf 100644 --- a/crates/ffi/src/aiur/aggregate.rs +++ b/crates/ffi/src/aiur/aggregate.rs @@ -25,7 +25,7 @@ use std::{ use aiur::{ G, function_channel, - synthesis::{AiurProof, AiurSystem}, + synthesis::{AiurProof, AiurSystem, GatedProve}, }; use ix_common::address::Address; use ix_kernel::shard::{AggNode, ShardManifest}; @@ -55,6 +55,7 @@ use rustc_hash::{FxHashMap, FxHashSet}; use super::lean_unbox_nat_as_usize; const CACHE_VERSION: u64 = 2; +const MIB: usize = 1024 * 1024; const GIB: usize = 1024 * 1024 * 1024; const WRAP_RAM_BYTES: usize = 195 * GIB; const STRUCTURAL_RAM_BYTES: usize = 195 * GIB; @@ -68,6 +69,11 @@ fn format_gib(bytes: usize) -> String { format!("{}.{:01}", tenths / 10, tenths % 10) } +fn format_mib(bytes: usize) -> String { + let tenths = bytes.saturating_mul(10) / MIB; + format!("{}.{:01}", tenths / 10, tenths % 10) +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] enum ChildKind { Ixvm, @@ -364,7 +370,7 @@ struct Slot { struct ProveContext<'a> { specs: &'a [SlotSpec], prepared: &'a [PreparedShard], - proofs: &'a [Arc], + proofs: Option<&'a [Arc]>, owner_by_address: &'a FxHashMap, ixvm_system: &'a AiurSystem, aggr_system: &'a AiurSystem, @@ -375,6 +381,8 @@ struct ProveContext<'a> { aggr_idx: usize, store_dir: &'a Path, cache_dir: Option<&'a Path>, + reprove_slot: Option, + write_outputs: bool, } #[derive(Clone, Copy)] @@ -389,10 +397,12 @@ struct RunConfig<'a> { jobs: usize, ram_budget_bytes: usize, structural_above: usize, + reprove_slot: Option, direct_joins: bool, plan_only: bool, cache_fri_bytes: &'a [u8], use_cache: bool, + write_outputs: bool, } fn projection_block(addr: &Address, constant: &Constant) -> Address { @@ -931,19 +941,33 @@ fn load_cached( Some((proof, address)) } -fn persist_wrapper( - store_dir: &Path, +fn wrapper_bytes( statement: &Statement, proof: &AiurProof, -) -> Result { - write_store(store_dir, &statement.claim_bytes)?; +) -> Result, String> { let proof_bytes = proof.to_bytes().map_err(|error| { format!("aggregate proof serialization failed: {error}") })?; let wrapper = IxonProof::new(statement.claim.clone(), proof_bytes); let mut bytes = Vec::new(); wrapper.put(&mut bytes); - write_store(store_dir, &bytes) + Ok(bytes) +} + +fn wrapper_address( + statement: &Statement, + proof: &AiurProof, +) -> Result { + Ok(Address::hash(&wrapper_bytes(statement, proof)?)) +} + +fn persist_wrapper( + store_dir: &Path, + statement: &Statement, + proof: &AiurProof, +) -> Result { + write_store(store_dir, &statement.claim_bytes)?; + write_store(store_dir, &wrapper_bytes(statement, proof)?) } fn persist_cached( @@ -952,6 +976,9 @@ fn persist_cached( spec: &SlotSpec, proof: &AiurProof, ) -> Option
{ + if !ctx.write_outputs { + return None; + } let cache_dir = ctx.cache_dir?; match (|| -> Result { let address = persist_wrapper(ctx.store_dir, &spec.statement, proof)?; @@ -1087,6 +1114,10 @@ fn structural_path_advice( Ok(paths) } +fn assumption_count(statement: &Statement) -> usize { + statement.assumptions.as_ref().map_or(0, |tree| tree.leaves.len()) +} + fn prove_aggregate( ctx: ProveContext<'_>, spec: &SlotSpec, @@ -1094,9 +1125,17 @@ fn prove_aggregate( right: Option<&Slot>, slot_index: usize, ) -> Result<(AiurProof, Option
), String> { - if let Some((proof, address)) = load_cached(ctx, slot_index, spec) { - return Ok((proof, Some(address))); + let replaying = ctx.reprove_slot == Some(slot_index); + if !replaying { + if let Some((proof, address)) = load_cached(ctx, slot_index, spec) { + return Ok((proof, Some(address))); + } + } else { + eprintln!( + "[aggregate] replay slot {slot_index}: bypassing its cache entry" + ); } + let started = Instant::now(); let left_system = match left.kind { ChildKind::Ixvm => ctx.ixvm_system, @@ -1184,16 +1223,60 @@ fn prove_aggregate( }); let mut public_input = packed_digest(ctx.allowed); public_input.extend(packed_digest(&spec.statement.claim_bytes)); - let (outer_claim, proof) = ctx.aggr_system.prove_ixvm( - ctx.aggr_idx, - &public_input, - &mut io, - execute_ix_aggr, - ); + let proving_started = Instant::now(); + let (outer_claim, proof, peak) = match ctx + .aggr_system + .prove_ixvm_within_budget( + ctx.aggr_idx, + &public_input, + &mut io, + execute_ix_aggr, + None, + false, + ) { + GatedProve::Proved { claim, proof, peak } => (claim, proof, peak), + GatedProve::Split { .. } | GatedProve::Measured { .. } => { + return Err("unbudgeted aggregate prove did not produce a proof".into()); + }, + }; + let proved_at = Instant::now(); if outer_claim != spec.outer_claim { return Err("aggregate prover returned an unexpected outer claim".into()); } let address = persist_cached(ctx, slot_index, spec, &proof); + if replaying { + let tree_bytes: usize = + tree_storage.iter().map(|tree| tree.bytes.len()).sum(); + let path_bytes: usize = + path_storage.iter().map(|(_, path)| path.len()).sum(); + let preimage_bytes: usize = + preimage_storage.iter().map(|(_, bytes)| bytes.len()).sum(); + let right_assumptions = + right.map_or(0, |slot| assumption_count(&slot.statement)); + eprintln!( + "[aggregate] replay slot {slot_index}: shape {shape}, {} subjects, assumptions {}/{}/{}, proof advice {}+{} MiB, {} trees/{} MiB, {} paths/{} MiB, preimages {} MiB, query-record peak {} GiB ({} bytes)", + spec.subject_count, + assumption_count(&left.statement), + right_assumptions, + assumption_count(&spec.statement), + format_mib(left_advice.len()), + format_mib(right_advice.len()), + tree_storage.len(), + format_mib(tree_bytes), + path_storage.len(), + format_mib(path_bytes), + format_mib(preimage_bytes), + format_gib(peak), + peak, + ); + eprintln!( + "[aggregate] replay slot {slot_index}: advice {:.3}s, execute+prove {:.3}s, persistence {:.3}s, total {:.3}s", + (proving_started - started).as_secs_f64(), + (proved_at - proving_started).as_secs_f64(), + proved_at.elapsed().as_secs_f64(), + started.elapsed().as_secs_f64(), + ); + } Ok((proof, address)) } @@ -1206,7 +1289,13 @@ fn prove_slot( match spec.op { PlanOp::Leaf(shard) => { let prepared = &ctx.prepared[shard]; - let wrapper = &ctx.proofs[shard]; + let wrapper = + ctx.proofs.and_then(|proofs| proofs.get(shard)).ok_or_else(|| { + format!( + "shard {} proof was not loaded for replay", + prepared.original_id + ) + })?; let proof = AiurProof::from_bytes(&wrapper.proof).map_err(|error| { format!("shard {} proof does not decode: {error}", prepared.original_id) })?; @@ -1278,6 +1367,104 @@ fn prove_slot( } } +#[derive(Debug, PartialEq, Eq)] +struct ReplayPlan { + children: Vec, + needs_input_proofs: bool, +} + +fn plan_replay( + specs: &[SlotSpec], + target: usize, +) -> Result { + let spec = specs.get(target).ok_or_else(|| { + format!( + "--reprove-slot {target} is out of range; the plan has slots 0..{}", + specs.len().saturating_sub(1) + ) + })?; + if spec.kind == ChildKind::Ixvm { + return Err(format!( + "--reprove-slot {target} selects a raw IxVM leaf, not a Stage 2 proof" + )); + } + let children = match spec.op { + PlanOp::Leaf(_) => Vec::new(), + PlanOp::Join(left, right) => vec![left, right], + }; + let needs_input_proofs = children.is_empty() + || children.iter().any(|index| specs[*index].kind == ChildKind::Ixvm); + Ok(ReplayPlan { children, needs_input_proofs }) +} + +fn load_replay_child( + ctx: ProveContext<'_>, + target: usize, + child_index: usize, +) -> Result, String> { + let spec = ctx + .specs + .get(child_index) + .ok_or("replay target has a missing child slot")?; + if spec.kind == ChildKind::Ixvm { + return prove_slot(ctx, child_index, &[]); + } + let (proof, proof_address) = load_cached(ctx, child_index, spec).ok_or_else(|| { + format!( + "replay slot {target} requires cached child slot {child_index}; run Stage 2 through that child first" + ) + })?; + Ok(Arc::new(Slot { + kind: ChildKind::Aggr, + statement: spec.statement.clone(), + outer_claim: spec.outer_claim.clone(), + proof, + proof_address: Some(proof_address), + claims_bytes: serialize_claims(&[&spec.outer_claim]), + })) +} + +fn run_replay( + ctx: ProveContext<'_>, + target: usize, + plan: &ReplayPlan, +) -> Result { + let started = Instant::now(); + eprintln!( + "[aggregate] replay slot {target}: loading {} immediate child proof(s)", + plan.children.len() + ); + let children: Vec> = plan + .children + .iter() + .map(|child| load_replay_child(ctx, target, *child)) + .collect::>()?; + let children_loaded_at = Instant::now(); + let slot = prove_slot(ctx, target, &children)?; + ctx.aggr_system.verify(&slot.outer_claim, &slot.proof).map_err(|error| { + format!("replayed slot {target} proof failed verification: {error:?}") + })?; + let verified_at = Instant::now(); + let persisted = slot.proof_address.is_some(); + let address = match slot.proof_address.as_ref() { + Some(address) => address.clone(), + None => wrapper_address(&slot.statement, &slot.proof)?, + }; + let disposition = if persisted { "persisted" } else { "not persisted" }; + eprintln!( + "[aggregate] replay slot {target}: proof {} ({disposition})", + address.hex() + ); + eprintln!( + "[aggregate] replay slot {target}: children {:.3}s, target+verify {:.3}s, address {:.3}s, end-to-end {:.3}s", + (children_loaded_at - started).as_secs_f64(), + (verified_at - children_loaded_at).as_secs_f64(), + verified_at.elapsed().as_secs_f64(), + started.elapsed().as_secs_f64(), + ); + Ok(address.hex()) +} + fn dependencies_complete(spec: &SlotSpec, completed: &[bool]) -> bool { match spec.op { PlanOp::Leaf(_) => true, @@ -1483,6 +1670,12 @@ fn run(config: RunConfig<'_>) -> Result { config.cache_fri_bytes.len() )); } + if config.plan_only && config.reprove_slot.is_some() { + return Err("--plan-only cannot be combined with --reprove-slot".into()); + } + if config.reprove_slot.is_some() && !config.use_cache { + return Err("--reprove-slot requires aggregate cache reads".into()); + } let started = Instant::now(); let manifest_bytes = fs::read(config.manifest_path).map_err(|error| { format!("read manifest {}: {error}", config.manifest_path.display()) @@ -1509,6 +1702,10 @@ fn run(config: RunConfig<'_>) -> Result { &allowed, config.cache_fri_bytes, )?; + let replay_plan = config + .reprove_slot + .map(|target| plan_replay(&specs, target)) + .transpose()?; let specs_at = Instant::now(); print_plan(&specs, &prepared.shards, config.structural_above); if config.plan_only { @@ -1528,14 +1725,34 @@ fn run(config: RunConfig<'_>) -> Result { let cache_path = ix_root.join("cache").join("aggregate"); let cache_dir = config.use_cache.then_some(cache_path.as_path()); if let Some(dir) = cache_dir { - fs::create_dir_all(dir).map_err(|error| { - format!("create aggregate cache {}: {error}", dir.display()) - })?; + if config.write_outputs { + fs::create_dir_all(dir).map_err(|error| { + format!("create aggregate cache {}: {error}", dir.display()) + })?; + } else if config.reprove_slot.is_some() && !dir.is_dir() { + return Err(format!( + "aggregate replay cache {} does not exist", + dir.display() + )); + } } else { eprintln!("[aggregate] cache disabled (--no-cache)"); } - let proofs = - load_input_proofs(config.proof_hexes, &store_dir, &prepared.shards)?; + if !config.write_outputs { + eprintln!("[aggregate] output writes disabled (--no-write)"); + } + let needs_input_proofs = + replay_plan.as_ref().is_none_or(|plan| plan.needs_input_proofs); + let proofs = if needs_input_proofs { + Some(load_input_proofs(config.proof_hexes, &store_dir, &prepared.shards)?) + } else { + let supplied = + config.proof_hexes.lines().filter(|line| !line.is_empty()).count(); + eprintln!( + "[aggregate] replay uses cached aggregate children; skipping {supplied} supplied shard proof wrapper(s)" + ); + None + }; let proofs_at = Instant::now(); eprintln!( "[aggregate] Rust startup: manifest {:.3}s, env/claims {:.3}s, plan/statements {:.3}s, proofs {:.3}s; total {:.3}s", @@ -1545,20 +1762,10 @@ fn run(config: RunConfig<'_>) -> Result { (proofs_at - specs_at).as_secs_f64(), (proofs_at - started).as_secs_f64(), ); - let jobs_label = if config.jobs == 0 { - "all ready slots".to_string() - } else { - config.jobs.to_string() - }; - eprintln!( - "[aggregate] scheduler: jobs={jobs_label}, RAM budget {} GiB; wrap/self 195.0 GiB, direct 390.0 GiB, mixed 340.0 GiB, flat +1 MiB/subject", - format_gib(config.ram_budget_bytes) - ); - let context = ProveContext { specs: &specs, prepared: &prepared.shards, - proofs: &proofs, + proofs: proofs.as_deref(), owner_by_address: &prepared.owner_by_address, ixvm_system: config.ixvm_system, aggr_system: config.aggr_system, @@ -1569,7 +1776,24 @@ fn run(config: RunConfig<'_>) -> Result { aggr_idx: config.aggr_idx, store_dir: &store_dir, cache_dir, + reprove_slot: config.reprove_slot, + write_outputs: config.write_outputs, }; + if let (Some(target), Some(plan)) = + (config.reprove_slot, replay_plan.as_ref()) + { + return run_replay(context, target, plan); + } + + let jobs_label = if config.jobs == 0 { + "all ready slots".to_string() + } else { + config.jobs.to_string() + }; + eprintln!( + "[aggregate] scheduler: jobs={jobs_label}, RAM budget {} GiB; wrap/self 195.0 GiB, direct 390.0 GiB, mixed 340.0 GiB, flat +1 MiB/subject", + format_gib(config.ram_budget_bytes) + ); let slots = run_scheduler(context, config.jobs, config.ram_budget_bytes)?; let root = slots.last().ok_or("aggregate plan produced no root slot")?; if root.kind != ChildKind::Aggr { @@ -1603,11 +1827,15 @@ fn run(config: RunConfig<'_>) -> Result { config.aggr_system.verify(&root.outer_claim, &root.proof).map_err( |error| format!("aggregate root proof failed verification: {error:?}"), )?; - let address = match &root.proof_address { - Some(address) => address.clone(), - None => persist_wrapper(&store_dir, &root.statement, &root.proof)?, + let (address, persisted) = match &root.proof_address { + Some(address) => (address.clone(), true), + None if config.write_outputs => { + (persist_wrapper(&store_dir, &root.statement, &root.proof)?, true) + }, + None => (wrapper_address(&root.statement, &root.proof)?, false), }; - eprintln!("[aggregate] root proof: {}", address.hex()); + let disposition = if persisted { "" } else { " (not persisted)" }; + eprintln!("[aggregate] root proof: {}{disposition}", address.hex()); Ok(address.hex()) } @@ -1633,12 +1861,16 @@ extern "C" fn rs_aiur_stage2_aggregate( jobs: LeanNat>, ram_budget_bytes: LeanNat>, structural_above: LeanNat>, + reprove_slot_code: LeanNat>, direct_joins: bool, plan_only: bool, cache_fri_bytes: LeanByteArray>, use_cache: bool, + write_outputs: bool, ) -> LeanExcept { let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let reprove_slot = + lean_unbox_nat_as_usize(reprove_slot_code.inner()).checked_sub(1); run(RunConfig { ixvm_system: ixvm_system.get(), aggr_system: aggr_system.get(), @@ -1650,10 +1882,12 @@ extern "C" fn rs_aiur_stage2_aggregate( jobs: lean_unbox_nat_as_usize(jobs.inner()), ram_budget_bytes: lean_unbox_nat_as_usize(ram_budget_bytes.inner()), structural_above: lean_unbox_nat_as_usize(structural_above.inner()), + reprove_slot, direct_joins, plan_only, cache_fri_bytes: cache_fri_bytes.as_bytes(), use_cache, + write_outputs, }) })); match result { @@ -1797,6 +2031,31 @@ mod tests { assert!(specs[2].structural); assert_eq!(specs[2].subject_count, 2); assert!(specs[2].statement.assumptions.is_none()); + assert_eq!( + plan_replay(&specs, 0).unwrap(), + ReplayPlan { children: Vec::new(), needs_input_proofs: true } + ); + assert_eq!( + plan_replay(&specs, 2).unwrap(), + ReplayPlan { children: vec![0, 1], needs_input_proofs: false } + ); + assert!(plan_replay(&specs, 3).unwrap_err().contains("out of range")); + + let direct_specs = build_specs( + &prepared, + 3, + 5, + 0, + true, + b"aggregate-vk", + b"allowed", + &[0; 40], + ) + .expect("direct native specs"); + assert!( + plan_replay(&direct_specs, 0).unwrap_err().contains("raw IxVM leaf") + ); + assert!(plan_replay(&direct_specs, 2).unwrap().needs_input_proofs); let paths = structural_path_advice( &specs[0].statement, &specs[1].statement, From 2472bff2b054d2c69d56fa09d8d4e664ff59ca79 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Thu, 3 Sep 2026 05:53:04 -0400 Subject: [PATCH 39/44] Audit aggregate proofs against every constant --- Ix/Cli/VerifyCmd.lean | 94 ++++++++++++++++++++++++++++++++++------ Tests/AggrSemantics.lean | 81 ++++++++++++++++++++++++++++++++++ 2 files changed, 162 insertions(+), 13 deletions(-) diff --git a/Ix/Cli/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean index 4fed82ecd..0fa8a7b7a 100644 --- a/Ix/Cli/VerifyCmd.lean +++ b/Ix/Cli/VerifyCmd.lean @@ -94,6 +94,58 @@ structure AggregateBackend where structure ExpectedAggregate where claim : Ix.Claim + constantCount : Nat + +/-- Decode a proof wrapper only after checking that its bytes reproduce the +content address supplied by the caller. `Store.read` selects a path by address +but deliberately does not re-hash ordinary store objects. -/ +def decodeAggregateWrapperAt (proofAddr : Address) (bytes : ByteArray) : + Except String Ixon.Proof := do + let actual := Address.blake3 bytes + if actual != proofAddr then + throw s!"aggregate proof store object {proofAddr} hashes to {actual}" + Ixon.Proof.de bytes + +/-- Establish the per-constant interpretation of an aggregate root. A valid +proof of `CheckEnv(subjects.root, none)` certifies every subject leaf, so this +single linear audit checks that those leaves are exactly the constants in the +supplied environment: no omissions, foreign leaves, or duplicates. -/ +def auditAggregateConstants (env : Ixon.Env) (statement : Aggr.CheckEnvTrees) : + Except String Nat := do + if let some assumptions := statement.assumptions then + throw s!"aggregate root retains undischarged assumptions {assumptions.root}" + let leaves := statement.subjects.leaves + let mut seen : Std.HashSet Address := {} + let mut duplicates := 0 + let mut foreign := 0 + let mut firstDuplicate : Option Address := none + let mut firstForeign : Option Address := none + for address in leaves do + if seen.contains address then + duplicates := duplicates + 1 + if firstDuplicate.isNone then firstDuplicate := some address + else + seen := seen.insert address + if !env.consts.contains address then + foreign := foreign + 1 + if firstForeign.isNone then firstForeign := some address + let mut missing := 0 + let mut firstMissing : Option Address := none + for (address, _) in env.consts do + if !seen.contains address then + missing := missing + 1 + if firstMissing.isNone then firstMissing := some address + if duplicates != 0 || foreign != 0 || missing != 0 then + let sample (address : Option Address) := address.map toString |>.getD "none" + throw s!"aggregate constant audit failed: {missing} missing \ + (first {sample firstMissing}), {foreign} foreign \ + (first {sample firstForeign}), {duplicates} duplicate occurrence(s) \ + (first {sample firstDuplicate}); environment has {env.consts.size} constants, \ + subject tree has {leaves.size} leaves" + if leaves.size != env.consts.size then + throw s!"aggregate constant audit cardinality mismatch: environment has \ + {env.consts.size} constants, subject tree has {leaves.size} leaves" + pure env.consts.size /-- Build the two deterministic systems whose identities are committed by an aggregate root: the IxVM vk and the single-entrypoint recursion vk. -/ @@ -125,28 +177,30 @@ private def buildAggregateBackend allowed } -private def shardStatement (env : Ixon.Env) (blocks : Array Address) : +private def shardStatement (env : Ixon.Env) (owned : 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. -/ +data is needed. Ownership is assigned for every retained shard in one +environment pass; verification must not reintroduce the old shard-by-shard +full-environment scan. -/ def expectedFromManifest (env : Ixon.Env) (view : Ix.Cli.CheckCmd.IxesManifestView) (structuralAbove : Nat) : Except String Aggr.CheckEnvTrees := do let (view, counts) ← view.pruneEmpty env + let owned := Ix.Cli.CheckCmd.ownedConstsPer env view.shards 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]? + let some shardOwned := owned[shard]? | throw s!"aggregate plan references missing shard {shard}" - slots := slots.push (← shardStatement env blocks) + slots := slots.push (← shardStatement env shardOwned) | .join left right => let some leftStatement := slots[left]? | throw s!"aggregate plan references missing left slot {left}" @@ -161,7 +215,10 @@ def expectedFromManifest (env : Ixon.Env) 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 bytes ← StoreIO.toIO (Store.read proofAddr) + let wrapper ← match decodeAggregateWrapperAt proofAddr bytes with + | .ok wrapper => pure wrapper + | .error e => IO.eprintln s!"error: {e}"; return 1 let .checkEnv _ _ := wrapper.claim | do IO.eprintln s!"error: aggregate proof {proofAddr} does not bundle a CheckEnv claim" return 1 @@ -181,6 +238,11 @@ private def verifyAggregateProof (backend : AggregateBackend) match backend.system.verify outerClaim proof with | .ok () => IO.println s!"ok: aggregate proof {proofAddr} verifies {wrapper.claim}" + if let some expected := expected? then + IO.println s!"[verify] aggregate coverage: {expected.constantCount}/\ + {expected.constantCount} environment constants committed exactly once" + IO.println s!"[verify] all {expected.constantCount} included constants \ + certified well-typed; 0 undischarged assumptions" return 0 | .error e => IO.eprintln s!"error: aggregate verification failed: {e}" @@ -288,7 +350,14 @@ def runVerifyCmdWith (recursionParameters : MultiStark.RecursionParameters) 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 }) + let statement : Aggr.CheckEnvTrees := { + subjects := expectedTree + assumptions := none + } + let constantCount ← match auditAggregateConstants env statement with + | .error e => IO.eprintln s!"error: {e}"; return 1 + | .ok count => pure count + pure (some { claim := statement.claim, constantCount }) | 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 @@ -301,11 +370,10 @@ def runVerifyCmdWith (recursionParameters : MultiStark.RecursionParameters) 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 }) + let constantCount ← match auditAggregateConstants env statement with + | .error e => IO.eprintln s!"error: {e}"; return 1 + | .ok count => pure count + pure (some { claim := statement.claim, constantCount }) | none, some _ => unreachable! let backend ← match ← buildAggregateBackend recursionParameters with | .error e => IO.eprintln e; return 1 @@ -347,7 +415,7 @@ def verifyCmd : Cli.Cmd := `[Cli| "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). 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." + "aggregate"; "Interpret proofs as single-entrypoint aggregate roots. With --ixe, audit every environment constant and bind the canonical claim; add --ixes for the exact manifest-relative hybrid root." "structural-above" : Nat; "For --aggregate + --ixes, reproduce structural joins above N subject leaves (default 4096; must match proving)." "record"; "With --ixe + --ixes and proof(s): after a proof binds to its shard and verifies, record it in the shard-proof index (`~/.ix/cache/shard-proofs/` → address) so `ix prove --skip-proven` and `ix shard refine` reuse it. How already-proved leaves are imported before a refinement." diff --git a/Tests/AggrSemantics.lean b/Tests/AggrSemantics.lean index 285bbcbfc..cd9578bba 100644 --- a/Tests/AggrSemantics.lean +++ b/Tests/AggrSemantics.lean @@ -276,6 +276,16 @@ def semanticSuite : IO UInt32 := do | .hit address => address == cachedAddress | _ => false let cachedBytes := Ixon.Proof.ser cachedWrapper + let wrapperContentAddressAccepted : Bool := + match Ix.Cli.VerifyCmd.decodeAggregateWrapperAt cachedAddress cachedBytes with + | .ok wrapper => + wrapper.claim == cachedWrapper.claim && wrapper.proof == cachedWrapper.proof + | .error _ => false + let wrapperContentAddressRejected : Bool := + let wrongAddress := Address.blake3 (cachedBytes.push 0xff) + match Ix.Cli.VerifyCmd.decodeAggregateWrapperAt wrongAddress cachedBytes with + | .error _ => true + | .ok _ => false let resumed? ← match wrapSpecs with | .ok specs => match specs[0]? with @@ -406,6 +416,63 @@ def semanticSuite : IO UInt32 := do treesFull.contains expectedFrontier.root | _, _ => false + -- A real aggregate-verifier audit fixture: two constants in one shard both + -- depend on a constant in the other. The structural fold must discharge the + -- frontier, and one verified stand-in aggregate proof then certifies exactly + -- the three constants committed by the root statement. + let (auditEnv, auditOwned, auditShared) := sharedClosureIxonEnv + let auditManifest := Ix.Cli.CheckCmd.parseIxesManifest + (minimalIxesFor #[auditOwned, #[auditShared]] + (#[1, 1, 0] ++ u32le4 0 ++ #[0] ++ u32le4 1)) + let auditStatement := auditManifest.bind fun view => + Ix.Cli.VerifyCmd.expectedFromManifest auditEnv view 0 + let aggregateProofAuditsEveryConstant ← match auditStatement with + | .error _ => pure false + | .ok statement => + let expectedOuter := Ix.Cli.AggregateCmd.aggregateOuterClaim + allowed fakeAggrIdx statement.claim + match selfSystem.prove fakeAggrIdx + (Aggr.pubInput allowed (Ix.Claim.ser statement.claim)) default with + | .error _ => pure false + | .ok (outer, proof, _) => + let wrapper : Ixon.Proof := { claim := statement.claim, proof := proof.toBytes } + let bytes := Ixon.Proof.ser wrapper + let address := Address.blake3 bytes + let decoded := match Ix.Cli.VerifyCmd.decodeAggregateWrapperAt address bytes with + | .ok decoded => decoded.claim == statement.claim && decoded.proof == proof.toBytes + | .error _ => false + let audited := match Ix.Cli.VerifyCmd.auditAggregateConstants auditEnv statement with + | .ok count => count == 3 + | .error _ => false + pure <| decoded && audited && outer == expectedOuter && + (selfSystem.verify expectedOuter proof).isOk + let auditLeaves := auditOwned.push auditShared + let rejected (result : Except String Nat) : Bool := + match result with + | .error _ => true + | .ok _ => false + let missingConstantRejected := + rejected (Ix.Cli.VerifyCmd.auditAggregateConstants auditEnv { + subjects := canonicalTree auditOwned + assumptions := none + }) + let foreignConstantRejected := + let foreign := Address.blake3 "aggregate-audit-foreign".toUTF8 + rejected (Ix.Cli.VerifyCmd.auditAggregateConstants auditEnv { + subjects := canonicalTree (auditLeaves.push foreign) + assumptions := none + }) + let duplicateConstantRejected := + rejected (Ix.Cli.VerifyCmd.auditAggregateConstants auditEnv { + subjects := .node (canonicalTree auditLeaves) (.leaf auditOwned[0]!) + assumptions := none + }) + let residualAssumptionRejected := + rejected (Ix.Cli.VerifyCmd.auditAggregateConstants auditEnv { + subjects := canonicalTree auditLeaves + assumptions := some (canonicalTree #[auditShared]) + }) + -- Threshold policy and the RAM-gated DAG controller. let mixedSchedule := Ix.Cli.AggregateCmd.schedulePlan manifestPlan #[2, 2, 1] 4 @@ -574,6 +641,10 @@ def semanticSuite : IO UInt32 := do 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 "aggregate verifier accepts a content-addressed proof wrapper" + wrapperContentAddressAccepted, + test "aggregate verifier rejects a wrapper stored under the wrong address" + wrapperContentAddressRejected, 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, @@ -603,6 +674,16 @@ def semanticSuite : IO UInt32 := do manifestValuesDiffer, test "shard prep preserves trees and one-pass closure semantics" shardPrepPreservesSemantics, + test "verified aggregate proof audit certifies every fixture constant" + aggregateProofAuditsEveryConstant, + test "aggregate constant audit rejects an omitted environment constant" + missingConstantRejected, + test "aggregate constant audit rejects a foreign subject" + foreignConstantRejected, + test "aggregate constant audit rejects a duplicate subject" + duplicateConstantRejected, + test "aggregate constant audit rejects residual assumptions" + residualAssumptionRejected, test "threshold scheduling is flat below and structural above monotonically" mixedScheduleCorrect, test "RAM-gated scheduler admits ready work heaviest-first" From 2f6b3f5ff018d9e1092d388c79d147e0b2ba9645 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Thu, 3 Sep 2026 06:32:54 -0400 Subject: [PATCH 40/44] Move aggregate verification orchestration to Rust --- Ix/Aiur/Protocol.lean | 17 +++ Ix/Cli/VerifyCmd.lean | 42 ++++-- Tests/AggrSemantics.lean | 20 ++- crates/ffi/src/aiur/aggregate.rs | 245 ++++++++++++++++++++++++------- crates/ffi/src/lean.rs | 2 + 5 files changed, 249 insertions(+), 77 deletions(-) diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index a3442a9a1..6858814a0 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -95,6 +95,14 @@ structure ProveEnvResult where ioMap : Array ((G × Array G) × IOKeyInfo) deriving Nonempty +/-- Manifest-bound aggregate root reconstructed and audited by the native +Stage 2 controller. `claimBytes` is the exact root `Ix.Claim` wire encoding; +`constantCount` is the number of environment constants proven to occur once. -/ +structure AggregateExpected where + claimBytes : ByteArray + constantCount : Nat + deriving Nonempty + namespace AiurSystem @[extern "rs_aiur_system_build"] @@ -214,6 +222,15 @@ opaque aggregateStage2 (ixvmSystem aggrSystem : @& AiurSystem) (useCache writeOutputs : Bool) : Except String String +/-- Reconstruct and audit the manifest-relative aggregate root entirely in +Rust, using the same ownership, frontier, pruning, and statement-fold code as +`aggregateStage2`. This is the native orchestration path for `ix verify` and +does not construct shard statements or schedule Lean tasks. -/ +@[extern "rs_aiur_aggregate_expected"] +opaque aggregateExpected (envHandle : @& EnvHandle) + (manifestPath : @& String) (structuralAbove : @& Nat) : + Except String AggregateExpected + @[extern "rs_aiur_system_prove_addr_with_env"] private opaque proveAddrWithEnv' : @& AiurSystem → @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → diff --git a/Ix/Cli/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean index 0fa8a7b7a..1b6bc5fe4 100644 --- a/Ix/Cli/VerifyCmd.lean +++ b/Ix/Cli/VerifyCmd.lean @@ -235,8 +235,10 @@ private def verifyAggregateProof (backend : AggregateBackend) return 1 let outerClaim := Ix.Cli.AggregateCmd.aggregateOuterClaim backend.allowed backend.aggrIdx wrapper.claim + let verifyStarted ← IO.monoMsNow match backend.system.verify outerClaim proof with | .ok () => + IO.println s!"[verify] aggregate Aiur proof: {(← IO.monoMsNow) - verifyStarted}ms" IO.println s!"ok: aggregate proof {proofAddr} verifies {wrapper.claim}" if let some expected := expected? then IO.println s!"[verify] aggregate coverage: {expected.constantCount}/\ @@ -334,8 +336,8 @@ def runVerifyCmdWith (recursionParameters : MultiStark.RecursionParameters) 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) + let ixePath? : Option String := (p.flag? "ixe").map (·.as! String) + let manifestPath? : Option String := (p.flag? "ixes").map (·.as! String) if manifestPath?.isSome && ixePath?.isNone then p.printError "error: aggregate verification with --ixes also requires --ixe" return 1 @@ -359,25 +361,33 @@ def runVerifyCmdWith (recursionParameters : MultiStark.RecursionParameters) | .ok count => pure count pure (some { claim := statement.claim, constantCount }) | 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 + let started ← IO.monoMsNow + let envHandle ← match ← IO.lazyPure fun _ => Aiur.EnvHandle.fromIxe ixePath with + | .error e => + IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}" + return 1 + | .ok handle => pure handle + let native ← match ← IO.lazyPure fun _ => + Aiur.AiurSystem.aggregateExpected envHandle manifestPath structuralAbove with + | .error e => + IO.eprintln s!"native aggregate manifest audit failed: {e}" + return 1 | .ok expected => pure expected - let constantCount ← match auditAggregateConstants env statement with - | .error e => IO.eprintln s!"error: {e}"; return 1 - | .ok count => pure count - pure (some { claim := statement.claim, constantCount }) + let claim ← match Ixon.runGet Ix.Claim.get native.claimBytes with + | .error e => + IO.eprintln s!"native aggregate root claim decode failed: {e}" + return 1 + | .ok claim => pure claim + IO.println s!"[verify] native manifest audit: {native.constantCount} constants in \ + {(← IO.monoMsNow) - started}ms" + pure (some { claim, constantCount := native.constantCount }) | none, some _ => unreachable! + let backendStarted ← IO.monoMsNow let backend ← match ← buildAggregateBackend recursionParameters with | .error e => IO.eprintln e; return 1 | .ok backend => pure backend + IO.println s!"[verify] aggregate backend setup: \ + {(← IO.monoMsNow) - backendStarted}ms" let mut rc : UInt32 := 0 for hex in proofs do let proofAddr ← addrOfHex! "aggregate proof" hex diff --git a/Tests/AggrSemantics.lean b/Tests/AggrSemantics.lean index cd9578bba..0e2b6e4f7 100644 --- a/Tests/AggrSemantics.lean +++ b/Tests/AggrSemantics.lean @@ -342,23 +342,33 @@ def semanticSuite : IO UInt32 := do statement.claim == .checkEnv (canonicalTree #[singleAddr]).root none | .error _ => false | .error _ => false - let nativePlanOnlyFfiWorks ← do + let (nativePlanOnlyFfiWorks, nativeVerifyRootMatches) ← do let dir ← IO.FS.createTempDir let ixePath := dir / "native-plan.ixe" let ixesPath := dir / "native-plan.ixes" match Ixon.serEnv singleEnv with - | .error _ => pure false + | .error _ => pure (false, false) | .ok envBytes => IO.FS.writeBinFile ixePath envBytes IO.FS.writeBinFile ixesPath <| minimalIxesFor #[#[singleAddr]] (#[1, 0] ++ u32le4 0 ++ #[0]) match Aiur.EnvHandle.fromIxe ixePath.toString with - | .error _ => pure false + | .error _ => pure (false, false) | .ok handle => - pure <| (ixvmSystem.aggregateStage2 selfSystem handle + let planWorks := (ixvmSystem.aggregateStage2 selfSystem handle ixesPath.toString "" verifyIdx fakeAggrIdx 1 (16 * 1024 * 1024 * 1024) 4096 0 false true childRecursionParameters.cacheFriBytes false true).isOk + let expectedMatches := match Aiur.AiurSystem.aggregateExpected + handle ixesPath.toString 4096 with + | .error _ => false + | .ok expected => + expected.constantCount == 1 && match + Ixon.runGet Ix.Claim.get expected.claimBytes with + | .ok claim => + claim == .checkEnv (canonicalTree #[singleAddr]).root none + | .error _ => false + pure (planWorks, expectedMatches) let (pairEnv, pairLeft, pairRight) := pairIxonEnv let pairManifest := Ix.Cli.CheckCmd.parseIxesManifest @@ -663,6 +673,8 @@ def semanticSuite : IO UInt32 := do test "one retained shard reconstructs one value-based root" singletonValueRoot, test "native Stage 2 FFI plans a serialized environment end-to-end" nativePlanOnlyFfiWorks, + test "native verifier orchestration reproduces the Stage 2 root claim" + nativeVerifyRootMatches, test "two-shard manifest passes exact environment coverage" pairCoverage, test "aggregate startup prepares every shard from one ownership pass" batchedShardPreparationCorrect, diff --git a/crates/ffi/src/aiur/aggregate.rs b/crates/ffi/src/aiur/aggregate.rs index fd9036ecf..daf9195f8 100644 --- a/crates/ffi/src/aiur/aggregate.rs +++ b/crates/ffi/src/aiur/aggregate.rs @@ -53,6 +53,7 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; use rustc_hash::{FxHashMap, FxHashSet}; use super::lean_unbox_nat_as_usize; +use crate::lean::LeanAiurAggregateExpected; const CACHE_VERSION: u64 = 2; const MIB: usize = 1024 * 1024; @@ -344,6 +345,14 @@ enum PlanOp { Join(usize, usize), } +#[derive(Debug)] +struct StatementSpec { + op: PlanOp, + statement: Arc, + subject_count: usize, + structural: bool, +} + #[derive(Debug)] struct SlotSpec { op: PlanOp, @@ -692,16 +701,13 @@ fn shape_ram_bytes(shape: u8, subject_count: usize) -> usize { } } -fn build_specs( +/// Build the claim-bearing statement at every aggregate slot. This is the +/// shared source of truth for proving and manifest-bound verification: the +/// verifier must not reconstruct the same DAG independently in Lean. +fn build_statement_specs( prepared: &PreparedRun, - verify_idx: usize, - aggr_idx: usize, structural_above: usize, - direct_joins: bool, - aggr_vk: &[u8], - allowed: &[u8], - cache_fri_bytes: &[u8], -) -> Result, String> { +) -> Result, String> { let shard_by_id: FxHashMap = prepared .shards .iter() @@ -710,35 +716,151 @@ fn build_specs( .collect(); let mut ops = Vec::new(); build_plan(&prepared.tree, &shard_by_id, &mut ops)?; - let raw_leaves = direct_joins && ops.len() > 1; - let mut specs: Vec = Vec::with_capacity(ops.len()); + let mut specs: Vec = Vec::with_capacity(ops.len()); for op in ops { match op { PlanOp::Leaf(shard) => { let prepared_shard = &prepared.shards[shard]; + specs.push(StatementSpec { + op, + statement: prepared_shard.statement.clone(), + subject_count: prepared_shard.statement.subjects.count, + structural: false, + }); + }, + PlanOp::Join(left_index, right_index) => { + let left = specs + .get(left_index) + .ok_or("aggregate plan has a missing left child")?; + let right = specs + .get(right_index) + .ok_or("aggregate plan has a missing right child")?; + let subject_count = + left.subject_count.saturating_add(right.subject_count); + let structural = subject_count > structural_above; + let statement = Statement::join( + &left.statement, + &right.statement, + structural, + &prepared.owner_by_address, + )?; + if statement.subjects.count != subject_count { + return Err("aggregate plan has inconsistent subject counts".into()); + } + specs.push(StatementSpec { op, statement, subject_count, structural }); + }, + } + } + Ok(specs) +} + +/// Check the semantic certificate attached to the root statement independently +/// of any proof: every environment constant occurs exactly once, every retained +/// shard contributes, the canonicalized subject root is the environment root, +/// and no assumption survives. +fn validate_root_statement( + prepared: &PreparedRun, + root: &Statement, +) -> Result<(), String> { + if root.subjects.count != prepared.env_count { + return Err(format!( + "aggregate root has {} subjects, environment has {}", + root.subjects.count, prepared.env_count + )); + } + if root.subjects.shards != prepared.expected_shards { + return Err("aggregate root does not contain every retained shard".into()); + } + let mut root_leaves = Vec::with_capacity(prepared.env_count); + root.subjects.collect_leaves(&mut root_leaves); + if root_leaves.len() != prepared.env_count { + return Err(format!( + "aggregate root tree contains {} subject occurrences, environment has {} constants", + root_leaves.len(), + prepared.env_count + )); + } + root_leaves.sort_unstable(); + if root_leaves.windows(2).any(|pair| pair[0] == pair[1]) { + return Err("aggregate root contains a duplicate subject".into()); + } + if let Some(foreign) = root_leaves + .iter() + .find(|addr| !prepared.owner_by_address.contains_key(*addr)) + { + return Err(format!( + "aggregate root contains foreign subject {}", + foreign.hex() + )); + } + let canonical_root = merkle_root_canonical_sorted(&root_leaves) + .ok_or("aggregate root has no subject leaves")?; + if canonical_root != prepared.env_root { + return Err(format!( + "aggregate root subjects canonicalize to {}, not environment root {}", + canonical_root.hex(), + prepared.env_root.hex() + )); + } + if root.assumptions.is_some() { + return Err("aggregate root retains undischarged assumptions".into()); + } + Ok(()) +} + +fn expected_from_manifest( + env: &ixon::Env, + manifest: &ShardManifest, + structural_above: usize, +) -> Result<(Arc, usize), String> { + let prepared = prepare_run(env, manifest)?; + let specs = build_statement_specs(&prepared, structural_above)?; + let root = specs + .last() + .ok_or("aggregate manifest produced no root statement")? + .statement + .clone(); + validate_root_statement(&prepared, &root)?; + Ok((root, prepared.env_count)) +} + +fn build_specs( + prepared: &PreparedRun, + verify_idx: usize, + aggr_idx: usize, + structural_above: usize, + direct_joins: bool, + aggr_vk: &[u8], + allowed: &[u8], + cache_fri_bytes: &[u8], +) -> Result, String> { + let statement_specs = build_statement_specs(prepared, structural_above)?; + let raw_leaves = direct_joins && statement_specs.len() > 1; + let mut specs: Vec = Vec::with_capacity(statement_specs.len()); + for statement_spec in statement_specs { + let StatementSpec { op, statement, subject_count, structural } = + statement_spec; + match op { + PlanOp::Leaf(_) => { let kind = if raw_leaves { ChildKind::Ixvm } else { ChildKind::Aggr }; let shape = (!raw_leaves).then_some(shape_code(ChildKind::Ixvm, None)); let outer_claim = if raw_leaves { - inner_claim(verify_idx, &prepared_shard.statement.claim_bytes) + inner_claim(verify_idx, &statement.claim_bytes) } else { - aggregate_outer_claim( - aggr_idx, - allowed, - &prepared_shard.statement.claim_bytes, - ) + aggregate_outer_claim(aggr_idx, allowed, &statement.claim_bytes) }; let key = cache_key(aggr_vk, cache_fri_bytes, &outer_claim); specs.push(SlotSpec { op, - statement: prepared_shard.statement.clone(), - subject_count: prepared_shard.statement.subjects.count, - structural: false, + statement, + subject_count, + structural, kind, shape, outer_claim, cache_key: key, ram_bytes: shape.map_or(RAW_SHARD_RAM_BYTES, |value| { - shape_ram_bytes(value, prepared_shard.statement.subjects.count) + shape_ram_bytes(value, subject_count) }), }); }, @@ -749,23 +871,11 @@ fn build_specs( let right = specs .get(right_index) .ok_or("aggregate plan has a missing right child")?; - let subject_count = - left.subject_count.saturating_add(right.subject_count); - let structural = subject_count > structural_above; let shape = if structural { structural_shape_code(left.kind, right.kind) } else { shape_code(left.kind, Some(right.kind)) }; - let statement = Statement::join( - &left.statement, - &right.statement, - structural, - &prepared.owner_by_address, - )?; - if statement.subjects.count != subject_count { - return Err("aggregate plan has inconsistent subject counts".into()); - } let outer_claim = aggregate_outer_claim(aggr_idx, allowed, &statement.claim_bytes); let key = cache_key(aggr_vk, cache_fri_bytes, &outer_claim); @@ -1799,31 +1909,7 @@ fn run(config: RunConfig<'_>) -> Result { if root.kind != ChildKind::Aggr { return Err("aggregate plan produced a raw IxVM root".into()); } - if root.statement.subjects.count != prepared.env_count { - return Err(format!( - "aggregate root has {} subjects, environment has {}", - root.statement.subjects.count, prepared.env_count - )); - } - if root.statement.subjects.shards != prepared.expected_shards { - return Err("aggregate root does not contain every retained shard".into()); - } - let mut root_leaves = Vec::with_capacity(prepared.env_count); - root.statement.subjects.collect_leaves(&mut root_leaves); - root_leaves.sort_unstable(); - root_leaves.dedup(); - let canonical_root = merkle_root_canonical_sorted(&root_leaves) - .ok_or("aggregate root has no subject leaves")?; - if canonical_root != prepared.env_root { - return Err(format!( - "aggregate root subjects canonicalize to {}, not environment root {}", - canonical_root.hex(), - prepared.env_root.hex() - )); - } - if root.statement.assumptions.is_some() { - return Err("aggregate root retains undischarged assumptions".into()); - } + validate_root_statement(&prepared, &root.statement)?; config.aggr_system.verify(&root.outer_claim, &root.proof).map_err( |error| format!("aggregate root proof failed verification: {error:?}"), )?; @@ -1847,6 +1933,43 @@ fn panic_text(payload: &Box) -> &str { .unwrap_or("unknown Rust panic") } +/// Native manifest/environment binding for `ix verify --aggregate --ixes`. +/// The returned claim comes from the exact statement builder used by Stage 2, +/// after a full constant/shard/assumption audit. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_aggregate_expected( + env_handle: LeanExternal>, + manifest_path: LeanString>, + structural_above: LeanNat>, +) -> LeanExcept { + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let manifest_bytes = + fs::read(Path::new(manifest_path.as_str())).map_err(|error| { + format!("read manifest {}: {error}", manifest_path.as_str()) + })?; + let manifest = ShardManifest::from_bytes(&manifest_bytes) + .map_err(|error| format!("manifest parse failed: {error}"))?; + expected_from_manifest( + &env_handle.get().env, + &manifest, + lean_unbox_nat_as_usize(structural_above.inner()), + ) + })); + match result { + Ok(Ok((statement, constant_count))) => { + let expected = LeanAiurAggregateExpected::alloc(0); + expected.set_obj(0, LeanByteArray::from_bytes(&statement.claim_bytes)); + expected.set_obj(1, LeanOwned::box_usize(constant_count)); + LeanExcept::ok(expected) + }, + Ok(Err(error)) => LeanExcept::error_string(&error), + Err(payload) => LeanExcept::error_string(&format!( + "native aggregate verification setup panicked: {}", + panic_text(&payload) + )), + } +} + /// Production FFI called once after Lean has compiled the IxVM and ixAggr /// systems. Proof addresses are newline-separated to keep the ABI flat. #[unsafe(no_mangle)] @@ -2031,6 +2154,14 @@ mod tests { assert!(specs[2].structural); assert_eq!(specs[2].subject_count, 2); assert!(specs[2].statement.assumptions.is_none()); + let (expected, constant_count) = + expected_from_manifest(&env, &manifest, 0).expect("native expected root"); + assert_eq!(constant_count, 2); + assert_eq!(expected.claim, specs[2].statement.claim); + let (flat_expected, flat_count) = + expected_from_manifest(&env, &manifest, 8).expect("flat expected root"); + assert_eq!(flat_count, 2); + assert_ne!(flat_expected.claim, expected.claim); assert_eq!( plan_replay(&specs, 0).unwrap(), ReplayPlan { children: Vec::new(), needs_input_proofs: true } diff --git a/crates/ffi/src/lean.rs b/crates/ffi/src/lean.rs index 58e574d2f..88831d502 100644 --- a/crates/ffi/src/lean.rs +++ b/crates/ffi/src/lean.rs @@ -298,6 +298,8 @@ lean_ffi::lean_inductive! { LeanAiurShardResult [ { num_obj: 4 } ]; // claimBytes, proof, peakBytes, suggestedParts LeanAiurShardProveResult [ { num_obj: 4 } ]; + // claimBytes, constantCount + LeanAiurAggregateExpected [ { num_obj: 2 } ]; // --- Block / comparison types --- From e92a44f518addd31e77a68b06ec8f9841c553b83 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Thu, 3 Sep 2026 06:44:38 -0400 Subject: [PATCH 41/44] Parallelize native aggregate preparation --- crates/ffi/src/aiur/aggregate.rs | 153 ++++++++++++++++++++++--------- 1 file changed, 111 insertions(+), 42 deletions(-) diff --git a/crates/ffi/src/aiur/aggregate.rs b/crates/ffi/src/aiur/aggregate.rs index daf9195f8..fc76e93cc 100644 --- a/crates/ffi/src/aiur/aggregate.rs +++ b/crates/ffi/src/aiur/aggregate.rs @@ -36,7 +36,7 @@ use ixon::{ MerklePath, leaf_hash, merkle_root_canonical_sorted, node_hash, zero_address, }, - shard_claim::thin_frontier, + shard_claim::walk_edges, }; use ixvm_codegen::{ aiur_ix_aggr_runner::{ @@ -50,6 +50,7 @@ use lean_ffi::object::{ LeanString, }; use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; +use rayon::prelude::*; use rustc_hash::{FxHashMap, FxHashSet}; use super::lean_unbox_nat_as_usize; @@ -450,25 +451,56 @@ fn prepare_run( } } + // DashMap iteration is deliberately unordered. Sort first so indexed Rayon + // collection and the later sequential fold retain deterministic errors and + // output independent of worker scheduling. + let mut all_addresses: Vec
= + env.consts.iter().map(|entry| entry.key().clone()).collect(); + all_addresses.par_sort_unstable(); + + // Materializing an .ixe constant parses its serialized representation, and + // lazy constants intentionally do not cache that representation. Classify + // ownership and extract the kernel walk edges in the same parallel pass so + // frontier construction does not parse all constants a second time. + let classified_results: Vec), String>> = + all_addresses + .par_iter() + .map(|addr| { + let constant = env + .try_get_const(addr) + .ok_or_else(|| { + format!("environment constant {} disappeared", addr.hex()) + })? + .map_err(|error| { + format!("cannot parse environment constant {}: {error}", addr.hex()) + })?; + let block = projection_block(addr, &constant); + let owner = block_to_shard.get(&block).copied().ok_or_else(|| { + format!( + "environment constant {} (block {}) has no owning manifest shard", + addr.hex(), + block.hex() + ) + })?; + let mut edges = Vec::new(); + walk_edges(&constant, &mut edges); + Ok((owner, edges)) + }) + .collect(); + // Resolve failures in canonical-address order rather than whichever Rayon + // worker happens to finish first. + let classified: Vec<(usize, Vec
)> = + classified_results.into_iter().collect::>()?; + let mut owned = vec![Vec::new(); manifest.shards.len()]; - let mut owner_old = FxHashMap::default(); - for entry in env.consts.iter() { - let addr = entry.key().clone(); - let constant = entry.value().get().map_err(|error| { - format!("cannot parse environment constant {}: {error}", addr.hex()) - })?; - let block = projection_block(&addr, &constant); - let owner = block_to_shard.get(&block).copied().ok_or_else(|| { - format!( - "environment constant {} (block {}) has no owning manifest shard", - addr.hex(), - block.hex() - ) - })?; + let mut walk_edges_by_shard = vec![Vec::new(); manifest.shards.len()]; + let mut owners_old = Vec::with_capacity(all_addresses.len()); + for (addr, (owner, edges)) in all_addresses.iter().zip(classified) { owned[owner].push(addr.clone()); - owner_old.insert(addr, owner); + walk_edges_by_shard[owner].extend(edges); + owners_old.push(owner); } - if owner_old.len() != env.consts.len() { + if owners_old.len() != env.consts.len() { return Err( "manifest ownership did not cover every environment constant".into(), ); @@ -496,33 +528,58 @@ fn prepare_run( for (retained, old) in retained_old.iter().copied().enumerate() { old_to_retained.insert(old, retained); } - let owner_by_address: FxHashMap = owner_old - .into_iter() - .map(|(address, old)| { - let retained = old_to_retained[&old]; - (address, retained) - }) + let owner_by_address: FxHashMap = all_addresses + .iter() + .cloned() + .zip(owners_old) + .map(|(address, old)| (address, old_to_retained[&old])) .collect(); - let mut shards = Vec::with_capacity(retained_old.len()); - for (retained, old) in retained_old.iter().copied().enumerate() { - let mut subjects = std::mem::take(&mut owned[old]); - subjects.sort_unstable(); - subjects.dedup(); - let frontier = thin_frontier(env, &subjects); - let subject_tree = SubjectTree::canonical( - subjects, - ShardSet::singleton(retained, retained_old.len()), - )?; - let assumptions = CanonicalTree::from_sorted(frontier)?; - let statement = Statement::new(subject_tree, assumptions); - shards - .push(PreparedShard { original_id: manifest.shards[old].id, statement }); - } + let shard_inputs: Vec<(usize, u32, Vec
, Vec
)> = + retained_old + .iter() + .copied() + .enumerate() + .map(|(retained, old)| { + ( + retained, + manifest.shards[old].id, + std::mem::take(&mut owned[old]), + std::mem::take(&mut walk_edges_by_shard[old]), + ) + }) + .collect(); + let shard_results: Vec> = shard_inputs + .into_par_iter() + .map(|(retained, original_id, subjects, candidates)| { + // Every environment constant has exactly one retained owner. Thus this + // is the thin-frontier predicate without rebuilding a subject hash set: + // retain present walk edges owned by another shard, exclude local and + // absent (including blob-sentinel) edges. + let mut frontier_set = FxHashSet::default(); + for candidate in candidates { + if owner_by_address + .get(&candidate) + .is_some_and(|owner| *owner != retained) + { + frontier_set.insert(candidate); + } + } + let mut frontier: Vec
= frontier_set.into_iter().collect(); + frontier.sort_unstable(); + let subject_tree = SubjectTree::canonical( + subjects, + ShardSet::singleton(retained, retained_old.len()), + )?; + let assumptions = CanonicalTree::from_sorted(frontier)?; + let statement = Statement::new(subject_tree, assumptions); + Ok(PreparedShard { original_id, statement }) + }) + .collect(); + // Retained-shard order is stable because Vec's parallel iterator is indexed; + // resolve any errors in that same order for deterministic diagnostics. + let shards = shard_results.into_iter().collect::, _>>()?; - let mut all_addresses: Vec
= - owner_by_address.keys().cloned().collect(); - all_addresses.sort_unstable(); let env_root = merkle_root_canonical_sorted(&all_addresses) .ok_or("cannot aggregate an empty environment")?; let expected_shards = ShardSet( @@ -2129,9 +2186,11 @@ mod tests { Expr::reference(0, Vec::new()), vec![dependency.clone()], ); + let reference_frontier = + ixon::shard_claim::thin_frontier(&env, std::slice::from_ref(&consumer)); let manifest = ShardManifest { num_shards: 2, - shards: vec![shard(0, consumer), shard(1, dependency.clone())], + shards: vec![shard(0, consumer.clone()), shard(1, dependency.clone())], total_cross_ingress: 0, tree: Some(AggNode::Internal( Box::new(AggNode::Leaf(0)), @@ -2139,6 +2198,16 @@ mod tests { )), }; let prepared = prepare_run(&env, &manifest).expect("native preparation"); + assert_eq!( + prepared.shards[0] + .statement + .assumptions + .as_ref() + .expect("cross-shard frontier") + .leaves + .as_ref(), + reference_frontier + ); let specs = build_specs( &prepared, 3, From 8069e6a1b147510efa4d47bd1e8c6a9fb98fcf57 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Thu, 3 Sep 2026 07:34:03 -0400 Subject: [PATCH 42/44] Fix typecheck benchmark shard prove handling --- Benchmarks/Typecheck.lean | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean index c20e69d9c..70db2d43b 100644 --- a/Benchmarks/Typecheck.lean +++ b/Benchmarks/Typecheck.lean @@ -664,11 +664,17 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do 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) + | .ok result => match result.proof with + | none => + .error s!"projected prover peak {result.peakBytes} bytes exceeds \ + the budget; suggested {result.suggestedParts} parts" + | some proof => + let digest := Address.blake3 result.claimBytes + let claim := + Aiur.buildClaim funIdx (IxVM.ClaimHarness.packedDigestKey digest) #[] + -- Shard proving no longer returns its whole ingested IO scope; + -- this benchmark never reads it after the proof is produced. + .ok (claim, proof, default, some result.claimBytes) else match aiurSystem.proveAddrWithEnv funIdx envHandle addr.hash useInterp with | .error e => .error e From d97519831cb710c3aa3fc51bd362d079edfed6af Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Thu, 3 Sep 2026 07:35:32 -0400 Subject: [PATCH 43/44] Add validated Mathlib Stage 2 fixture --- Tests/AggrSemantics.lean | 75 ++++++++++++++ .../mathlib-2026-09-03/PROVENANCE.md | 92 ++++++++++++++++++ ...a62a688ef20684fdc327739d38bd67f.ixon-proof | Bin 0 -> 9813583 bytes 3 files changed, 167 insertions(+) create mode 100644 Tests/Fixtures/Aggregate/mathlib-2026-09-03/PROVENANCE.md create mode 100644 Tests/Fixtures/Aggregate/mathlib-2026-09-03/c2fdce660eb66899efa303b41d4ca1611a62a688ef20684fdc327739d38bd67f.ixon-proof diff --git a/Tests/AggrSemantics.lean b/Tests/AggrSemantics.lean index 0e2b6e4f7..70b78dfc7 100644 --- a/Tests/AggrSemantics.lean +++ b/Tests/AggrSemantics.lean @@ -73,6 +73,78 @@ private def sharedClosureIxonEnv : Ixon.Env × Array Address × Address := |>.storeConst rightAddress right (env, #[leftAddress, rightAddress], sharedAddress) +private def stage2FixtureAddressHex : String := + "c2fdce660eb66899efa303b41d4ca1611a62a688ef20684fdc327739d38bd67f" + +private def stage2FixtureRootHex : String := + "3211abb340539c10220990fb095f8763cb3a364e111ebe57fb518992d42d7382" + +private def stage2FixturePath : System.FilePath := + "Tests" / "Fixtures" / "Aggregate" / "mathlib-2026-09-03" / + s!"{stage2FixtureAddressHex}.ixon-proof" + +private def stage2FixtureStorePath (home : System.FilePath) : System.FilePath := + home / ".ix" / "store" / "c2" / "fd" / "ce" / + "660eb66899efa303b41d4ca1611a62a688ef20684fdc327739d38bd67f" + +/-- Pin a real whole-Mathlib root at the persisted-proof boundary. The 3.33 GB +environment and 52.5 MB manifest are identified in the adjacent provenance +record rather than checked in; this gate re-hashes and decodes the exact +wrapper, pins its unconditional root claim, and drives native cryptographic +verification through the production CLI/backend. -/ +private def stage2FixtureValid : IO Bool := do + try + unless (← stage2FixturePath.pathExists) do + IO.eprintln s!"Stage 2 fixture missing: {stage2FixturePath}" + return false + let bytes ← IO.FS.readBinFile stage2FixturePath + if bytes.size != 9_813_583 then + IO.eprintln s!"Stage 2 fixture is {bytes.size} bytes, expected 9813583" + return false + let some address := Address.fromString stage2FixtureAddressHex | do + IO.eprintln "invalid pinned Stage 2 fixture address" + return false + let some root := Address.fromString stage2FixtureRootHex | do + IO.eprintln "invalid pinned Stage 2 fixture root" + return false + let wrapper ← match Ix.Cli.VerifyCmd.decodeAggregateWrapperAt address bytes with + | .error e => IO.eprintln s!"Stage 2 fixture wrapper rejected: {e}"; return false + | .ok wrapper => pure wrapper + if wrapper.claim != .checkEnv root none then + IO.eprintln s!"Stage 2 fixture claim drifted: {wrapper.claim}" + return false + let ixExe : System.FilePath := ".lake" / "build" / "bin" / "ix" + unless (← ixExe.pathExists) do + IO.eprintln s!"{ixExe} missing — run `lake build IxTests` first" + return false + let exe ← IO.FS.realPath ixExe + let home ← IO.FS.createTempDir + try + let storePath := stage2FixtureStorePath home + let some storeDir := storePath.parent | do + IO.eprintln s!"Stage 2 fixture store path has no parent: {storePath}" + return false + IO.FS.createDirAll storeDir + IO.FS.writeBinFile storePath bytes + let out ← IO.Process.output { + cmd := "env" + args := #[s!"HOME={home}", exe.toString, "verify", "--aggregate", + stage2FixtureAddressHex] } + if out.exitCode != 0 then + IO.eprintln s!"Stage 2 fixture verification failed ({out.exitCode}): \ +{out.stderr.take 500}" + return false + unless out.stdout.contains s!"ok: aggregate proof {stage2FixtureAddressHex} verifies" do + IO.eprintln s!"Stage 2 fixture verifier returned no success marker: \ +{out.stdout.takeEnd 500}" + return false + return true + finally + IO.FS.removeDirAll home + catch e => + IO.eprintln s!"Stage 2 fixture test failed: {e}" + return false + def semanticSuite : IO UInt32 := do let childCompiled ← match childProgram.compile with | .error e => IO.eprintln s!"aggr semantic child compilation failed: {e}"; return 1 @@ -482,6 +554,7 @@ def semanticSuite : IO UInt32 := do subjects := canonicalTree auditLeaves assumptions := some (canonicalTree #[auditShared]) }) + let productionStage2FixtureValid ← stage2FixtureValid -- Threshold policy and the RAM-gated DAG controller. let mixedSchedule := Ix.Cli.AggregateCmd.schedulePlan @@ -688,6 +761,8 @@ def semanticSuite : IO UInt32 := do shardPrepPreservesSemantics, test "verified aggregate proof audit certifies every fixture constant" aggregateProofAuditsEveryConstant, + test "dated Mathlib Stage 2 proof verifies under the production backend" + productionStage2FixtureValid, test "aggregate constant audit rejects an omitted environment constant" missingConstantRejected, test "aggregate constant audit rejects a foreign subject" diff --git a/Tests/Fixtures/Aggregate/mathlib-2026-09-03/PROVENANCE.md b/Tests/Fixtures/Aggregate/mathlib-2026-09-03/PROVENANCE.md new file mode 100644 index 000000000..0254e3c00 --- /dev/null +++ b/Tests/Fixtures/Aggregate/mathlib-2026-09-03/PROVENANCE.md @@ -0,0 +1,92 @@ +# Mathlib Stage 2 aggregate proof — 2026-09-03 + +This directory contains a real production Aiur-FRI Stage 2 root proof for a +complete Mathlib environment. The dated directory is intentional: a future +protocol, verifying-key, parameter, or Mathlib-environment update should add a +new dated fixture rather than silently replacing this record. + +## Artifact identity + +- File: + `c2fdce660eb66899efa303b41d4ca1611a62a688ef20684fdc327739d38bd67f.ixon-proof` +- Format: serialized `Ixon.Proof` containing a `CheckEnv` claim and compact + Aiur proof bytes +- Ixon content address (BLAKE3): + `c2fdce660eb66899efa303b41d4ca1611a62a688ef20684fdc327739d38bd67f` +- SHA-256: + `1a3cc584d5ab8cfba51fb5457aca13b643020b3684281d49472f9d0a21df1df1` +- Size: 9,813,583 bytes (9.36 MiB) +- Root claim: + `CheckEnv(3211abb340539c10220990fb095f8763cb3a364e111ebe57fb518992d42d7382, none)` + +## Inputs and producer + +- Environment: `mathlib.ixe`, 3,326,434,731 bytes, SHA-256 + `1044785de558aa99f93bca19d1e03b239289485d54cc458168b86851f4734609` +- Final manifest: `mathlib-233r-proved.ixes`, 52,548,538 bytes, SHA-256 + `c889f696272a865fed43ba1690c0795ac7c3d4d58c7ff386149cfbaff5778ee4` +- Environment constants: 679,499 +- Retained shards: 239 +- Stage 1 recovery revision: + `54da708f12a7d1e07d19716e9000cb78cb5df553` +- Stage 2 producer revision: + `77d132d80c65efd9d7d65136a7f4e3466e36ab9a` +- Prover: 64-vCPU CPU box with approximately 495 GiB usable RAM +- Recursion policy: production defaults (q=100), wrap-first, + `--structural-above 4096`, `--jobs 2`, `--max-ram 450` + +The production command started at `2026-09-02T19:01:35Z`: + +```console +xargs -a proof-addresses-r.txt -n 239 -x ix aggregate \ + --ixe mathlib.ixe \ + --ixes mathlib-233r-proved.ixes \ + --jobs 2 \ + --max-ram 450 +``` + +It completed all 477 slots (239 wraps and 238 joins) in 14:46:26 with exit +status 0. Peak process RSS was 515,028,732 KiB (491.2 GiB), with zero swaps. + +## Full validation + +The root was subsequently validated against both original inputs with the +manifest-bound production verifier: + +```console +ix verify --aggregate \ + --ixe mathlib.ixe \ + --ixes mathlib-233r-proved.ixes \ + c2fdce660eb66899efa303b41d4ca1611a62a688ef20684fdc327739d38bd67f +``` + +At revision `e92a44f518addd31e77a68b06ec8f9841c553b83`, validation established: + +- the wrapper reproduces its content address; +- the Aiur proof verifies under the production `ix_aggr` system; +- the proof claim equals the exact manifest-relative root claim; +- all 679,499 environment constants occur exactly once; +- there are no missing, duplicate, or foreign constants; and +- the root has zero undischarged assumptions. + +The parallel native audit took 2.939 seconds, backend setup 174 milliseconds, +and proof verification 51 milliseconds (3.23 seconds total wall time). + +The repository test deliberately does not commit the 3.33 GB environment or +52.5 MB manifest. It pins the wrapper size, content address, decoded claim, +absence of assumptions, and native verification under the current production +backend. Repeating the full constant-coverage audit requires input artifacts +matching the SHA-256 values above. + +## Updating this fixture + +1. Produce a new complete Stage 2 root and run the manifest-bound validation + command above against the exact source environment and manifest. +2. Create a new `mathlib-YYYY-MM-DD` directory and copy the root object from + its fanout path under `~/.ix/store` without transforming it. +3. Record the producer and validator revisions, input hashes, proof address, + claim, parameters, slot count, timings, and peak RSS in the new provenance + file. +4. Update the fixture constants in `Tests/AggrSemantics.lean` and run + `lake exe IxTests ix-aggr` plus the standard formatting, Clippy, and test + gates. diff --git a/Tests/Fixtures/Aggregate/mathlib-2026-09-03/c2fdce660eb66899efa303b41d4ca1611a62a688ef20684fdc327739d38bd67f.ixon-proof b/Tests/Fixtures/Aggregate/mathlib-2026-09-03/c2fdce660eb66899efa303b41d4ca1611a62a688ef20684fdc327739d38bd67f.ixon-proof new file mode 100644 index 0000000000000000000000000000000000000000..c8f4e14432607e06a268f3a48c2f701a205318bd GIT binary patch literal 9813583 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 z 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

x8D#5C0nXd{+U~{FqdrKV&0Ca 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

>zo}SIp7s)!z~)OYU(*i(`=AR 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ξ4@S)~o|3jeI1 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�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

u$?w29(k|ecaRTF~_<$h*> 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

rI;F#npG2CPSYGSs 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

3ZZ=d_` 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%0Dr;jVW)%M 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 z
u)qYQ;ZaY03kL8GUQu_j?B|ZL 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

ntC}FlqsM_=(7ig@WW-5BsYk#&YWLR$R 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 z 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�A5c8 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%0D*x#+9Pp7 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 L*20%G62?cxG9IMFK8W6K)~`wO%HoSOf24 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%0D3|Qj2HvSti_&9(tdvUpuP+)L^bAR^ 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Ã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

D+K#-Ho>EWnw+|J!;0 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ⅅ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 z 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

Ia9$NE6lGyFLwWJ_w& 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

u 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≶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⃬N@+I(Vl7 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Νi0(ik|Iv@Bz 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 z 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

FezV*G!0-52UR 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

y{$#-Jpg$lkIXT8+3KpCuRyp&a6NX;p7&F03 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%0AejXcG0lDjB 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 z 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

moQ$~pqq(4jse)R|)nqkGxGNxa!HEWtXceCIp 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�S_Abrgwp}}a!90P&?EA3l!iDB*@y{TT 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

c5^kzlCC4S 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�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

h@&&`zjY_k)e_LG@6x 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 z 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

Z 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

3zu5@sc)4iGb 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]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/Ma%%(qfc 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

(JO(J}__2 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 {^s`3XhvuV@ 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 jQB}aMcYLEgEEd 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

_EBI;HvnMb7lp3vg#Jg(%Bj- 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%0Dr#esv+^zOK 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 z

l5n{l7FR^&DUSI4Dd@SZmetR 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 J?%9N2W^AW+MYx$^D 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

fq>* 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 NNuq)SvFDI| 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�^B%vl`i9Rn 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%0DAz1_<$t8hpr#XG1(rYc2GR`8cLSuqxv?PkT4 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�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 z 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 N4ReGE;?>z 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 +tu{N0OiIr z%#$V^8XI^{(AqerrARM)GSa2D8`zHLfx%AO-*&5DZ#0ybYJJfgO8!WH^R3~$y1tcs zav|1NKUVbJQ)GuW*ui)~!l$Yz--Y}ByMF5{Z63EvqjDe61Hb<7OGsnjEoPXPITQ8`%vRYl>HP}H6P{;gPh2j7gz?T6KLEbvTY_Mo3A<0`n>1Q zjMug8rKWz2bRuf$YqDm%>oWu2u^7i;Ga+4OcTLI^aJ}!!B`;cdqeF!52gkq{jltmR z7P~_B{9;M!sf;gyz`*1jhRgC5TyAD`4~*6oMq2(@ITJRE8r3U42W-k6JlEl0jfwo^ zx{fpiTe??jPYEds!j)tYm3bd?wirI~sPU}Z(WbeudG#vDG*6SFw6G|-;hLdL>aDh6 zvVDq<1rmHP;&jHTz${0lzyqzs+4np@%^XemIrTn`pr|2k``BzEs0~OQJ2YzsD_qki z@L@-x7DjNqe{0blCtlqA-}x8(@!VHD9BxPnUTX{S;&mcp!%0yxr_TxBFX;+bQ<||9 znB%I#Cxi5N3!|3%eo3QfC~tKUg_h5M(0GK^92+vVC>udUmwz%*_@P*4owwy|N#Q*$ zS-8p^(OX)6EJg*5(z1SMrMUYGv@em+57y@UQ^M#jtFxXn4*rh0qCHhjr(>@-?ly5f z`EA$&C%rTC=0oG&(~;TJSSj%z{gDf$*yQ3CA%2psY;SR7(Br-nnHt-@An8Zpp#%Q?rRTx7`5m^Fn&fc7mc0iM7gmQTTCxigLHe}Bgu6u%}<7hL; zC(yFUr}2}DMAXq2*hUvopP)T$+dPa3Uv5+c4I;X{H;#_7TXqk&lulssm(~>cmh*si zX1x;H%X*2q6j#QH+kApC0q}pK#Jj$ADc#u%Y7geBp5aiwKjZ&9d1^*ivHWjymLwU=bADZ>2rq4%@iWKJ~!!z8W#bzGHClv zkKBia2dmm%ww!Aj+0UeC*vd-zR%8}NDMY>|Fdxj7{vIx;uQ2QKINh2XHO4``HXE5C zeT2*y4x}zm>~kuafWl3K&*3)JAZ>!yh`_=7kty)!RFde&tg%@_f-XnDm+AoEk7X^Vp%vbe1&-PN!E4mjbw$Ci{Cqy_mN#~ z4vqYyLDIwZ6teOsaxqh<$TG(dXr_qdotaENd*#>+W$P(pEc2bmhli)*Q!JO59#$MG zhCGe+j@D|KZ3}dGT5eojz)C)!SIlACEWPcKeP)90%KK=?DY(8?-MFK`SE~1evdDz! zn-ybQf@qHz`N)Xwsm<+3%Dj=vvTITQg~u0SmTq$42ZgraU25~>6H{0J$EA_g0}Lw9 z<`vJ8lXM-f6nIb#iN1Z*RVi1EcKucwn@`I~LKn8Xk@%VICZ=0eULjr}_$lMQn!?#} zx*PX%nE{emMEFs~sIRX2u^#(6?^M#b-0!`!T!6{6xF_g)ZSf(_nB;Tc$^iSNcqtO& z_!B%y{TYqlMnzs#E;;C;7gK53w46862VI5kLyHl*15ke7Lay_+8A}tt%vc-r9S=UV&IGWEtwJNLq# z(tfR?`1mtPI5#v$D>bfs`jJkDRK~AldN#qYwoKt{)`IwBKH(4b9(fjqyq|wG3%?>%^IZ*3f&jkQd>@?ypr*6qF$u4o&z7f8WcEWR#nbo-M3r1RT~!Y*ZJry7gbvjrB*J2na9g!g{rB(LZsW zIBdRrvNJLp+8ynX1|$3=yv4#(O18hTbZ#C2Tkyg3s1M8}R-cGW{|OSNZ6nOQALd~9x)-bLPp1#oQCw|PUU@Yqz=45E| zmaw=~;s@5wmY`#|#OJ6NnlGa53)5$pQ_c5jwuOT5XIbwtc71t@@x;7fMn!?dfYzjj z_jx)=>E|2oEz0sudt3kKyZ-yzyKZ(kbymAiYF&;%H$ zOM}bFtI3C-bl;;=I>v4|`y}>cP_%WsaD)3YNcTf|L8%VHx6ab{s|FXjB-&_0z4VHY z_hQvAr1%$Ds;)<-?4GE^tI8aHDP>hLQT=VsFE@t#9DdXdIZgO0y?bSO?^VXsQ>F3t zx9xVtQo3vlIDX{*Ny>Q-sWxr+y^|8&RqHKpo{ne_HvZ7 z-*(HDIlRnrRD^76cCO74em7q{#+IafUq@SH%-PDw13rJfc9-b;`7?-koE`hXxQ4c$XhhwiZ9ZPSqOIBu~sqUn(hT9y1v)JR_Clb>rd8iiJaxc>JR!|o|3Ng0h?1!o(T7=pf21f+W)P6ROw+kW~=g{hl&*M;GAAyf$?8Zj>MTg2O zSKX4EAvA+x_~7AY<{KCzBrHw%63gDC$R`23oXx^IRajd z(1@yMv%Oy=_aN;7{UJBw_si{y*R);+44-OBQP)V%wNLV2TquVROvG=%@r9MDe2oU`B4z*oo- zM!0m7Geta}BeNTFEm~HZz3k^L99~t9C`dwletfO_*zSBA$F!Y!Hni0kyJuW==i@I< zss7+DY?1Y)okS0N$q-ILDa3vWR0VYNdg*Dmb8=$;BxB@0uXqaaPowBo$wkx%{n)nm zE6dfxTNOU3PGCk>&NRN3QMI~c!dw<#dPsb6QQkIgq(^ZtNtSuf>vA>Bda!@Q$ZSoG z`O*9g-5YPGrwHfrZ-8rT?J(wIo0pbyB^E$n zwU6S-bA0K_vl=fXsB}7JyID*Pqsl5N_fp5j*^?1t?y1H+`vdbtYQ>TdJ0e(!Bw z`V7R{$Z0>9wB9?_Ip5(n&q{Jy+Jc3{e8P-dPcK`kkdWC0<=61h$1V}~;ojh)6AT#r7k)#O@# zdBrCj`3E{3!GOQh9Nio8H1(xf$x}wWr>ts7#Ksol#F`7-IbRBhnOvN0InKLgd<^M2dt}yJ;I&d9GgVFcU;JUYd7brvIka^J z`Bm>pdvJH_2+xPYP{kg8F%5mDm@7#PC;3{lWqUpV5NAGVTMpPXs4EBL;;Id3EuC(0%F#n@aCl@moaoH4u+ zNcnQDZ-ks=W@42hIQ#m(ed_UhBpI?tuMT$tai~XS1CeqP^G)Dr@&~oMsO8!j&V5;i zBvlz;;EVx(tKDyVpHz_KKzu*D>m~dste{VXcTw4kUsDt*tU=#6-}b`2bL%=!b?J;! z`pz{G6h3^EEpsHvOGn5*5}3_1v9^ck+b^8(%(4TGa!}Rx$h}^ILWT4{Ec0q2!JJt2}lACZxamB~^gukUZ10#7;!+GaWH?76Z@P z5P~)CGFSvuVz^n#@#izySuwk4IdHVqrq z4;VZ-#M|7TIx7|V+wW8b{LICh1!M^!US@AGiAx1kY$87qie9i`lM`MMg!+06MhG6E z$R)g;XQn+vC8l6)>wRZB8@JifA}rK@GxuF})W#GKw_@8A4Mlf$)Wn{@THu8!n$w!b*|vWc(BQBF)T z{NkPBN6{K;Z=;Y)O`=s-^oC?N?6uIq)VAYy{Elu?cL>fA*T&0~*7eKD;=ekeNGwVUL#(^D8{HJ3=Tbx+L2E9+ev=^HsZvp~Wuwoeri|Wqv zI~cU2R=P1*=qu9rQ{H`A*R1}9<}_O+be0AD)6wnJtx@M;JHcB@VQOxP(O_)$a^~13 zQPu6TV$@%EE(1sqE-{GCA1SO*-524E5L=_f(I(7zYAV;^aRMX0$lYLkeLpXxte9QU z$z1O_ZMA40#_t07o0J1R@1wE2`8)2uHmW34Oy^OS-|qr`ETljQy4`?E%2UFfZ`Z0D z>h4@!X3Y!d)`XrF3_8S2Se65N)1ry#cL7D}HdWvgInZ`BmuXm_QZXV67Nt)gb5!Y$ z3>&=6*~8>No74Z>*ka#2u5|n$30ec1n<5xgE-G5iorpw{x-j~X3@QdIa8)|nKAO8-WWL7mRHRL@#9f-!`|v}ENldd+U_>2WoeA$(b! zS|;gQz&|oT?%Ji2)uXk17QwL}a2rC#zS7)=};2l9^`vZyH1A^RY2)?kQ7 zc}QmxfY?-Gwf$&C&`zGM34E2%MZi7;4Kjk8t0$!+b_WPt=8`lv0L5phY4JfD2+P=F z;>++sH=mW;_q*0#k6nAi-8@_@Dgb$Pjc>SDLi|d}{Mx&y(?Dt!TfJ=G@4NPdJ6673KvwK%Ot=IUk=EaNv2$ah#!Bevz@uyo+ zb2l~#17@XphI~6W=la;bc`X!=P3uU-eql!M-cQH_@yqiT)_5xg{egXkv63sI}6#?^untzjj+gu?3^ZE4^9Sj7+`Hg<-W$?t_u>I{m%dxk3 zY+!zfMQ^mu+j)%dZ(m<)U_eHm-}qo)ery>pudk+{AZ7w@^1WanVf}A*@PYW1t-Yl~ z3hL)k_VoIy4h~Y?`bJBD`VmpR>3KUukJtK5PZA6WpUIniCMbx*(OWz$aF7kFH@!(< zey}}n@dQCYaAn`{ZFgr?&zrm;s9$WtoBmHAeog*wv^S_9XULl#cNh?up|^N%hfFSJ zyvdt_{Syx4FS7bgP6@W0eyjy=dj8Kc7!ZI);8^nY zouc%6PQnjs;VdWI=1Vm)#P^=<|bC`$ztF=gf!dFC}(#eM-t1pPI*Q zwo8wI^7}V7@jXqrin`tDF2H!ylv<7-NUsxU!)Jfz>N-hMwYOIf_#Gq1HKBoWJXV&w zQlSPEdypj5R7ATt#lr6oVX#>~W#9kS3$zP@RxrVz-t&pW&C`lau)l7aE#*K*Os{H8 zlVvM!?Sm}^#UM7v$Nsg(m|GlEFztpe3LOdK8&%}p)Vq^O@nuymkOQc z&j;i9JDvYmG|+y$swr~@i#wYQ;oKd z4b?D5$=2W|PPJ~1+tx3-xwqr_v5KB7eW)gTyW&;Gm=FV6P^P9}@Eul1anJ@*@BSE$ z#KvpyS^ibTw8KuZaZ#j#>0pbggX}l>IlFb(ZC6MJ5xzo8{f>8zPv>H{3xWErmgHwm zEk*Rjg}IgtIg~CzDt7Fz0*IPs|IQD?AZnW}wamaZHvc7>9;1;`ILa5}K)N#RR}0Tw z@BT1>^jHVF8GrO`0{q6f&o&(4Y26;if^3wjJ!j@fYIUDE&PB=sP*O7D_DE7@ zbvf6#PYZHJD??mIkVOfTKzx`pM0kX=^%|{!1##+B@Ay43)k*U|C{!^wWyhVF#U@|{ zEu4f632YatUj6#aIN{R1II=ukA?&&pL44sKswx7u5P>7P7=lA+q6=9wN=59%jM4vJ zGX5VJvG-*`qsbkd?Bt6rh!FwJ0R9KDe;e#)$<*U}Hm~(7=vvtrp&u5An37feP;0F4 zq*<;m{h=Kb1>pZDG?L`zKFo#90!y+6D>bJq1@J$~{kw3bhIXgSd(y59S)6pr=0>EU zpFVNFiWbVPEGC8 z?+CH@{+3_3#MppX{IL3nv^dNHEvWo=_g0#msMVB?P#qf#Ir^&hXtyiV-x+yF+Z--u!6lJVO1VaPfj4y6*dU;dA6*)^M z4aiS^TD(;p!gzeLVaBK8&MLGYhoALt!Ua@ZpYYP|%CzC|TPEd4TG~loAf8-~#VbPr zd=_AWW5z1SRIf+j-JWE3E4W{$xNnwYRKJ)m_@*f34K&C}o&@WR_-wuN&pc;{QhwNv z>kJk5?69nCyR=TLW+OaURo+c{N1`7rAHGTwTY;P2y*3@5v=gu)#s;o8UkS@^$YDmC z9-)((?nEtk^$0#JW3_serY-f)8R^315Ya!F4ZtW0iSD%bgG`JB&f-4rFH6|n9Qw4v z5FtSnd#&u#f!d|_U%lN@CxgG8>&E{Wv<3$@^OcjP44U{BkyInpEBdIra>5qjV(wC> zlb-MfT~_7D5|gy`+qUvNYje_uXG>mP3fh=1WBufWcju>?gZ;U3CRM+-MUrCj!Bj|m z^+>CtbM%2V3QF+95$%AENfL-#`F$TcLvx$cWr2$J-zJ~(5F9L0lB5R}S*0BkTn`iS;=lJCkWkXEFJ%@TNERHXQBuaX9Q(TH> zp|VXoP055KzNYVXAl@MtE}kNYstbIs=D49g5oWuy0mFCJw@^;YBDBF6Q$t|&&;gs& zcx5*y<5#i91*Dr=2H0fcDv@*!*(kK@d2##CvY8>}nr&hm@E#kD-B!VTa4Atf9bV(! zOtW^vhlN|?u;^lWsgRUsgZqMSCMxU#GJ}0?Pwkt-pIjFRo0(tx8s|*4+XM2Izt->z zj~-xC6}p@qZt<$Y>K79iELJg`mU{cN=g5}DNX%DHXV zuADz=S&zYz`cO}uL9=a{b~H_2++G~rQ0&KqBfu(dQ%JMN;#~Q5eY6gCNRLTWm~5Z5 zha#m<YeZF z)Bf;4v+2n@&zB@=Qq7KuDaJJzZT`deYvFqJ0r2W{LR;E0#?cQ5hwGhLYpkp?B%Lul zvUTj~>{sIo`TiP#JpHXQ2Oyh?pmVi7o{GwoYsztm4>x zM{|OD2$73H-5ZznJc+Cnh6kr8gX;!dOw5;G{sh}%u#*PM5(i0 zr?7j8|7RSY5KAW7(V!_-r^(X}CUx^85YI8gMR%>#=UR1G2;-#DHV{uixTG1*tAj^~c06n=MekA6j{}2Y^t2;H6O;DtW`p}ekFvxzZ=>Oij#)TTR zZ=oH<<}|fzo5qFkQhtco4vwX2+uXUweUGPLt-K|ZHS?&+ST&H(%==}Y)&PPIZ0D%a zAu>a|I?4qP9WcbS4_NEaq)6A;})R@+Q}A%*PY`K7u;^hU14O3+X#FpF6E=kusno#|a!eE#n5D510|j%8rQ|#E?qf=+ zuX=*+W9X8j_ZT87`s2nBdu0T8DT!B4$NVe_Ov*T55wyCyt3BTBQze&x8cHp$w(0S8 zo{#sw4CEMmGgPEZfe0^JG>E?PY}6^dDYO>o5NK49Dl9-rFSFwXr@k!{kcw1R+#fzi zlSFOjk4&1xaN7y_z6)Q@?ZjcD1*68r-e<0-aKtND)>~A5n~ft{O3hgfhmklBjL@x`UeReyzTN>vbw*0-bA z*w74XXpA}N)9>XIF`2Cpmla}ZuMdbjyCs4Q<)U8u+3*mk@WXiko|PG4=dn`W#YqW^ z5pIW>uL+TS+Lx@pi~DLzS{>UzxI{1kftjm^5C5fH0;z7!ibgN=nQ_UM=FGcvv^@_^ zlA>}hEGDy)$1h6g*9b0E{x7?2Y;E$uHH^UJNkNm2imog9d_FOeWNK084DE5KB|AA; zu_gUxdBnrIOfCGGnzSk*W(-;9DV^TBi|cwGug$9plCVHRfjRO|f(-~M-tUa9;H2L* zJDfd&<=U|P{NmB-qNxq;nrB(`GEr-{R$Tn5%A17oOJjDrbQ1a7M>e4g0r(x79Ci0= znSnZ&ME*Rt+uft7U@tuVcY%q_*Y|338+&j-)Lj zPTEy4v1x*)w7fcJ6Q+!jBgKXiv2dd~i%wz>`N;+|=Yt<*Q$iA74a6$f*JM7!Cg&e% zuEJAa%Furu*m9+iQzv(R($wX{0j6oZvXcI71R?rt`(t-N|-C3#ULB2Q3?LVRe@}g;p zjZo1gbQ8{==`qJ#`b>m^ev{%>%z8e&OA6a!?e@Myv$FFkUAoZC^Kems^yi{qLJ7*F zJs~L*XNf6ZZhX)x<|lc2>Q|c92T52`qJf+4W{+(hlzX{RyK!BVbfDBygczzRXOs@D|+o8pyQ(x(@gnx6QO zS0qw9-;)n=qY5PBBTVqk*w^2H=S}MqC(~E?jKVa8Y{<~FultIhm^TS|cX|39tYioMW2=y;b#F2{rj zOL+pF3ZJIMD zO%Y8Q;Y8sO^l|vMeA#WRyYE%r|AAnHH)~(WIrKhhWtFOJ9!f7-Iw{D-yGWwMVOub8 z{F3YX@d|=JpHE6J*L(#`K0dDI{4h;(z%u}i(naT(dIitfY6%~QtefNJj$&|a7yf(% zEtWX+k~i|VQgc}l`4b1k5F2O?rFm)n%!m*a3ODEDFRqW|W#LZbE1#H2oIsRMsq!y= zwmzP{XR(vuX;0IOLcIO_xtgtpYK9X%xPI7p`-Ee|u@pWHZ#o-eup0TM0B0?pCQ;lX ze*Ayy&*|pvpWk<)s2|UISnRz*&s*k*8*7xisAoQIAQCFChjj*yPIMkw>_|;&r;5u{ zb|zPD@_|MSBO1EHqnLjvJ~B68du|uJJcal3!DW0GPi?Ju5z)ZvyZnVz7Y# zT*HFo)YM<3r0#juwY|Co?vJ$HDMqeC7pJkXw z`*nGjwvXyPOTyJL3R7q3O-Y-4XNjg_F$+aFS*v=Y7{8+INlXRT@K!~lYMpUgk%3sD zWM&V)>!Nq#>ApFdnEB1bF4cev(*M1T#|n;bGk)KCXBxQH;6E1EoDLhOa(u=A@?HBM z1^-0&TOMM=_S0|d+nb8YqUQHQ0?@$5&P;p|Cl5S3@qrKlyWfk4`$IcIaJch7a~Q=$ zIJWx*_J+d0{*Ij~S{87z>!NS?*WJ_qHyb*$51Y2}^SvRCSdQVp3+j%r=Zfc2pgpoHRUwOapEY z%F-^#({$$uB_qio%;dDrN6zpiWECvRQ%9sq4k5>K7Tow@5Ffvm$e~)=Lz%C=C&Rk& zX?qd!Eh-j!O#11FA+k*1s2AoQ4lhWMhnzCN3Efe}Z@0_)712hs;(NskB~fe-ZY$$= z5q5o{99YAkVjVP1VN>BJuZ54B;v%{e(l?pp57M9l45WB`Je>XD5qhfLx~Fk`FH6X7 zLS33_26?cK$0;VrQyO`2)`C6LuKnrE3U&l32iDjNJX|8OT+-aYcW?5DaZR?G^$eH( zyJpWKv0EL@I`z29Pcl*R!EA2Xc@l%@(IYe&x45!;2_5m0@A5j4sKt{{Z z;qDKYL$e9=F=W}5wZMD)6ZEN(Ja&*=p*fFlL^DW-tqG7+C$8;D=bY6I;xm=U-ielI=% zdWvh!KZ5WQw_rs-1o55QfXZnpV4ucWs8$uwip}PAy~tX=9`&Y10)El22zi@H=d`k2fvoqWZRF8&I9x){hU{lqA}T< zZc5X}dyHJ}r0SjnSJhr>bP|-xR;tR1h_rs)X?^5@cR-Ns8WD4*Ucfy=X`5L;lMqbP zp>_J{!2EjN;^FFU7veY`Y3H7Y`p1xdxzYo@WC^IjG@|$%bVz=v-?wZp*NR6?3PnB> z6|?rjC^*!{QGqiWqMOyzpC@lB29jiKGH7xDe#oW5bsifhJh=NS9cV_-KkcAi_SijJ ze-W}FAEW89Be>*BWHt)UM_%&Qvi&Pz@j9pV@O>R^adr3-WW*HO1jc&mKlWsQnQXr3 zPQa0o%j{lAXk+iKD@dy@KX`$o%33__)insym(E%Q7vt~fj{=+a&ME2(=y;n`h}uOc z3djh=n}?l;70e=87k&cbd9iQ^O5*gvEU1=4GjR@hWJ!pP=ck&S-c^o#->W`UOPw6T zts$f&0iFw2+eTAKmD>GO6=^dxPBXS)WbpNex}=YQ{t(uh#x(;CXM&mFM5CPFVJj98 zY}Dz$rEz=A?k+$bs!2wAsj%M7|1-W?pWb}ABfg@zpi1z9yQknZ-ecw1l35$09-n2& zcKKxk$Oox43*$FNnc?Lt4M)*t$T6NNS&XobS`43Ha2j#4u>h@k4b6kNM3}^P{dlJq z5(-h;IYqypoF~!D^0UYo`IFzT>4BzRgVh7`oA$`VPw^~=^XZeHKPe1VfQeAPAP5~f zOci@e;L@vaxG3a0&pXXW{J6;Ipd$IwTO+{F`jVun7&w3PvI=@U9dA&R#X8GXii_$s z>p&o54)cwdP**!*`4iwLpdBI)gpJQltAoQGZX)ECAiK(K^yM@5KMvO9l}!;V-!?`U zN((SzZg_==)vJmf;m(iu*8;yp`+y6e_li88$pdxkc5=uGEoMa3YLJUq?CA~zkj}qD za8!fECVrww{s+qu;rop+Al?f|f?|UCi2{HCA4m_N0sLDYhzHEy#I_O%fB0JJPj$^@ z%sj)2glf-)KP0MKp0HDWd>WucM!L9uo7ry3jlrLs7U)@`TO?Jk- z??OKBwALnBszC$eFq8ena|B%nx8Qd>rwYR+uL0APo-tjDET57@$hDq3Is1nDrh*`5 z(i;fwe-XKFumRzc8OL&%{Ul?iTbtP$6pa;J!-o@6V{1ie*ZM3YH((clT&d*-y8XLj zU0`7knt45YPmLmseJV)i49$(2G6Tm3-*301e>Fy0N986yrH^@Ohz(lea|!n;9rSRbU*D z9uN;eK^r@Z)lA|`drM5CF!7o=fDa%Kxz9%z$gvG`2z$}MFSZxfWXuAwH`v1k(nBDe z2k*Oo8bjEW&CoMb{1LF|*>DpKqZ2On48FS}iOqVU`MCmffc}9`D0trL3f^KA?Vfdu zI~l=A^WG}eGz?WC`j!8TeXr|zxjc;Eq^BF>s?Sdxfkvg|N<;+r%xB$74E0^VlovR_ zF9nU+YWM6Oy+|;M74FwDo_3;xEI$)~u{A5v;2nq~6qzj{@M>wn3)=i<(KOjI-l5mi z+v(5B+pOsnMVv$`N2u%9aT?t|3FMFLa}qiW_59^}KUHQNy_ zx(f^|Jm^1a*lAe;7F0_ITe40Tk`H;t z)^JmUt0ngsg(Jo|Hl*Vn{+8}zW|?Z9uLU7zX<-KV{CsmtRKK7Ng9l35q-X17T4zF` zMxh`q(Q{~GuFO?hoKcMS(7_@YtF0o>1;0s6m!CHL@Z`DlPuhB-bf3SGy?srF6yjl0gs!Xn|@C?*SkaSU27-S4%-fD8a6^hQib@I!5Fe(CECp(n3CC9D& zYX+CNL?$SVt_bCS`txMuBK&;SN`R z>OzFtDyJEs9TD$TS4^)w5;Mau69#8bL(!+TW?pEKt6s`lYI?u7ITd$0InWRHiV5&t z52jbe1D_bRH*!26oW-f|LZiWwS+{o7x!3F|d1RIVz0sSPH}3a)V?1rmhM0%nEhGXm zOps47`{iO^U?GUOpKE2Edgq?zoB=*jh%idb?9xwOh!%QGoM9|J^yH03T+>&#uDfki=v#8C^F}u-@-h0Y_zw65i#Zs6mL1S6j|r6*RT3`;HJ&Y4;pXV}2&G@3PrrE38kVU|nOs+N z0|C$#sXe(g`uQ{AiWSFCRU$4>bRN*%RyDaN-Q2DtMSh+hMAzaDyW8Ku`KYqEEx(cm zF3q}J3CzuhHerDWC2Y-AqU@~v!#e`9L!o`~x#N3ojqM=%Kl5S0_tr^qqDVz8TM>}| z4uRxFW5W7aKo5{_;CxabU4Z|$KLEM^Ekd7qjuEt4vaX%*Xf$h~v;qj|?eDY--j^sL z0p%`|UzK`EoEfrHv5&{?t^2&+^F1JO|B5wRx|}&o*A3!r;{CBG8%sq|IO)mVvXdP_ zuL&x5Mh@LO5&63wk8EtQOqmM*(eK?PzOpGFp0GAfXF&!Z_*C{hhR3tb-EUMSl{2V2 z=DZba7h;5t6U@KEW8|Xby%)!XUVcc{@*p4TQM02_$6go6eDUVInPpn|ey_cc@cnRP zX5#(Cs{ryJgE{f>{7bFB&$Z%eSwv!d$NqKji9zF+@}r=tg0aKd4&mH{8-@#&+>-@z zKbRuL=P^Rqg@Y(EvytU%6d6kqXcv9N3O32`9eDARc+2vxwWrA!ftxRtExL|r{k!AM zO4UGoD)_U;Va+qrnM3^hCsPH)jo-;;vYKEE0@@?8Mm?MJQAfIjI zjyxE>>2Dx>B)||)rRs9!$0!%?fRT1ZFGP;_qE{sA*ZIbZQZI?~SupvlrJ&k`Mhr-H zF-`&M#i;fpPI8n@KySz4;0=??glXkS-pvK9rRo||F$Gr2`)Ww#NK_ajgJNeazJ1Pb zR<8LeRV~8kzwJ!81`p6W(9G@Yg*McDm(Z8!gx~#kcK86)`_#VT&}l^s;R?=VEh`>3 zpqhbjG0ZhGp{aTk|8j8&ggZ(#?#?I5xUm%h@)4UvgJpa~HnVn^8ey~nJAE{X$z?5C z+SnP@?ZRP6G2zftv`Vs~;~I*}sSvW`nmYk*)${wV<^j;Vg&H32af4-{fhR}bfY1L= zdk%yH2(04-=H-F&eE~ZFJ}`d`JWm)+k3-TAW6q26L!FZ*;w$)%i}olYAU82|nr~;& z6${%yv3ZmyJXh12|H!6Ur`aXm;f+(r#=f`E@CCzhFLOuiTY=oMPn5NTv96k`?>1bV zVV+-`Y|jFan&z|nJOmXKFRS>I76eZOV2=<^zC9>N*()`5yIv3H)(_<~s-9JNuC%-! znk!}RfZS?SQ05N?5z2rbKn}o!qE4wLX8~~~nbH&{@ZXg$1y|$B_70x`1mXemZW3u* z5F3@l!1F}KcF`Z$r7t2Eo#DRm%6*h(OlsV?xf;yB<`VFN26k{jm$_B**=*|C4bi*-lI?8riE zBWDX@T?jalYyHK4oP18h>=EYP88R22J({4U(Rvsfg#a8NH%#ABTN|KzKUA$}j~m_0 z8y8bu!!;|_JXZ&MpJ zDxOYO*;WoqM4QtVgZkY|#INrrNL{_8PXcfbmfiZP%MYuFLMu(q;{HqT4`PX2_q9PJ z46PQ9Y1ft#CAYpW%B!C@vE?7V9SFPm1-?TZrL(HkTO2Vg!aI9AxVr(H76wb(|_0gOQC#@7^4M4ARl^}c5J~y4+nqe2lc+E zrJH7xe+t4cig0JM;os#aDQjCQUAM>Q=}SU(XJNqR-}wUgf>X^Ep_N>5rs1zn3n07K zO+!nJ8$C66EJ7;<>yNG)(PU~Ejb7^1;|Ke3`l2>0klnlh%uL(D2tW8*WZXOL8xRV<- zy`zr!EodM{9(u=xzc~r9o*|t~8HJy1S88AorznuE)?^R4@JuS7GEds@iS2-i)=STs z7O0m%Isj58fb+kTti=2#z^k#+dB(e;NH^gbC9MnS1@LeAYbh!S(Sc*gfgeoRbA2IBIQ0l|zckm(X3JqN0;Y%Xm z3%6eFnDnGP2S8ngQ|Cx_^THm+=wq)k}Q9|ERYXG zKcNr_SeC^0eQhIp@`{`Q%-5e)oCV ztu1jX569mN2*X73jppn{7@(MFgR zk*y5jJ@!-mSXmIoc~LQc=5#6aqUlm0e3{V%96nvmEr5!in;={MGmO+k@o7mi#(W2jca8zbJyIf$%}7Toa9W zHEAN2(=}*U)5P*S8hZoYp(?N>*js~pU+?uwR*R38bv(I+k_AA#U;(CFr~V?{?3;d) zEm%j_TmKnwkhEYqz#n=Xa07S)O8IRI;lhxwc=Iyc=O=`||7Sg6_$;nz6eRcjISYS} z2}Aoo;}1Z(>$D^GL=fab?bRl@LWxJ!Ma*iVmg=J1K==|Rg}69Y0!{J-vL~)X>=z6i zw^!lT9>*k^{gkCom(j`5k|TW}cA?6ac>{gQNWAJF{Cf=u1?V6`@ehbeg}JxnTXlB;GQe(Rj^Srdk&7)QH|V)y7}Nl{#nBEvdVpY6c0f2KkO zSK!h-Q~dt*YfqziZAeo(?DYKCs+YEcu*-tR;o@7X7;D*S{!2MddKyomV)f5}KcteF zc1ydDEC9N^w%}oH#QdXnV^6zzSfX~>fwewUhVqXXn5xB5ScYdc;om$fIqe{js-H{+o48E3Y#!idRdY5+gV@Hn3p1+Hec*{N+P4C6R z51LLLB)WeSSMci^fl)rwZfkuqchNz@;6eJ2BB0*@ z`W>Rctl336!mz*liJoCP69?#2{<*+fy=*I{DD`pLaAPmEF`&Ny`X^Ag*s9I|9jl9t z_$-9dBJVA!q)45y^H`ui`@8@8yMF@uGoXI~`m-+ujdFSr%GF?bsgB{tUvWr|gM?o) zm?{jT1tm|a^KJk;00j7ZHrPcq@p^QzF3davYwzyx(k#hSjf9(SHClh1FvCzZdM$dO z(YBNszMZt07I>=+^us_u2IvF)4%l<WO#}b6Np+)v@K43494v=nl4(!{d2=od7 z{dYLvum3IoZ~6a31NH#pc#O_fY%+ej0q+$_l!6suOKjVkQTIQfK)-_B6AARd-Y;I$-~51j=jEtD!><)rB&0#YnQUEZ)G!hx?1#VR7~i)Ca?%a z(%n8e9%)KmgGfw6;TMt_eTM;$H((dQpY#2cb=eNVRecgr5o~)9Bi0bT$?7Jft9x;4 zR!l)9a5oNl6*>NtS7(1(KK!MDOw~qalm(p_n?eC2q9PEO!oxEihj2x8K^p zM_kM7>(c;xfpq`22iGE6Kc=cr_TQyjHS;quuUVTu@q_2rZZEtoU>@iAwFuKF=i}X! zxo1Glr;ep+6Hw?A$|c2f`Gs}YI(-U7jOCy5peTI+f4%MC?sZ(&Z-T5o1#6FlnvcqU zA5|PQX6meXhzcd^2S|PIuFV0C892EIY7P+`CSpebzb`Nbf*n!WbYGhx<%qd&%D3<`^vj1+p78t+XsPUotSx_p?Y{C&umYfYiA~x1H zWT{jKw6DN@TfjK?&dO)YT7Ntz;9e>KQEgn$CnIsQ0lArz%RMk6n+70#0Dbf_l$5-AMqs z8U1!9RU7_h>qutvq`qO-7ZMd3=A?&g#R){q^e_F6?@UcxXPKB}#8;GEJZ!vgu)!^nlNwZa(a0Dne`two!LN6RDEeCIiQV) z`y!*M>r@$j-DS_x`fF=3@s@D}4*BZ@t)|@cU3Bqb&ExYjTEN2wUs96R0pO?-e)w>- z1W=m~Ty=((dUS4Gpx$Hrp5TJqM8_NKDyE7!+leEmp!**IeoHSa5*7k>FF>=-!{xP& zig>o!T*)TICRa75AK*!f4<_z1$)OEafe(pBU^h{EYX6c~Y_B<`#vC|WJGm2$aNINg0e{y_3|37N-974-v*xyYFP(h6no>A(x@y;!*lG*g-6? z7uCgG&F<3t%7%!`G>6VAPgReVyrV(+7+)N77A7A6_ov{wLH9!8viEM|+!Yv}V<)}{ zOo+OZ&7htR>@N;<)jyj6_m={E2rXgc!bh)`Z)z9@gAbfB=vd$j#uzg>Q-NNbeoE{c zN`Lec?Fr*dx|TN{C+8E>KO-&WU!XnN?MY=gSX@Um6;~gjX+wunN8Sbk{0X;ry7`Tx z3?6^?PNG zx{C@*%2--^3pFzQ=CgaOz2fEKPrsJ@?H&R)Z%~^u21$0ZJk4DGWJIHESbGP1pC^>! z5Gqw{`a629@DCr*OsYOEWSAiNwZ&pc@^i3hOWs1Yvx4`~0DhX_3*HqP~Q>yBX<^RXc~D(%ajdP9*kS<5dge9&b0mPOt3ZTaAF#k(Pwuc@xFyV#t7 zp7$2|r_wa(MgR?@Q{^Iiu^^^00Pq1j5CXYwEDYdi0X|@-bv*g~Z@1oPfDhzjBp3BL zD8b_j-~;)ju6_Z*s$$gw_<$cmI!+*phK}EM#{cUF_-Su+5r$(Yp9J6oeiUCGK^U{n&a3&k-`{1cSLC3coYE9w+hEx6GB@2Adtv*VRg$>6uF|h0nnNN;e)fcpIV`7Cec{ypsXujQ^MwIX%QjUKdp`IFr%VeektDUC zpJh-VJ6mMMMloHzbHx(M2{Lh8RnN4H?M(dY=VvQvWpGU-aNPx`S%LM>3s6v~S&c!Q zgDc{_3;tv@k!+STVxL#C!kJF;yKbDae!92*dNNCGXf%P?1#GmJRwWU$%S|~g)iob- zT@`vl+(As^%mD8IzCVsmv8vNShNVb8sMgbKF{xpfDzL1Z^E&=upmtspJVhp+W3HAx z-8xxD%2=~Eikz9s&sh+ja-;dWQ{7;IHo-$2Hlx)aL9UEi-g&)+@9$uj=8JF=ES6yG z3Zp&Kmo|9KYf2S=^5bb};J+ZuY)mRxDAId8gw_ zkAG#xkkDZucs)@MGs`FQbo*%sLHw)98ir`$sj~6YPx{1Q#4OQyLMZmkIjgs2+JAm| zmF)z_0v)3qU;X>mMH=a$I+3^A4UgqF8?tYUZ7uSm9X$v4vU3-Z{=^T<$3s$KWbWLd z$cC#fJ{bC+t~&tU69EM5;i!^;sJygv%{BXZW8Jyh51iAIU{RdAu*24|f+z1(eYeT~ z1J2HgzLlW{KtR4mGi`fiI9LjS49;;ZCqNv?D1F}riD%_!&826!QaK6xP8LEB%*jQ} z40Oij!273iOmTU&^r5+)ZvcNc`RU<{TuJ=Hv+LL*57(SBZPX9^M~SIYd&5Nw|% zn4Z!5!-AD3;k&_2Whv@V9-+WOTG+lsBpI4Un{)Tqs&(8l<9z5Iq~Ohz!1?XrR5SqT z5WG#%%Z#6?t@uIptsyjl1sg%65BXD(Gl*4<5tHOm`N^!U`&)Z*!|)=_>9J}jHPM=a zNUXkXY`==RqmR3bCaY^y+Iqh%*vUyicrx{l*V7W^U(Flo!BzkHj05R9#ynrLuJSUi zgd4VepBuvSVeY3Q&lNiYZz`moGY$;iGD23iY!fS7DVNz{jz2c=y_#{o=uIj3n5jQN zWW*ktXMNyc85;g=DVCr?q)vm38`9elCC^wr-*vpsbUWATSYzw)-Ld#;j6Vta$DX;f z-Z*v^UhAlvECmwDyDTzwv|qL^&?R~GlI0!<&(p{<%h!N??=5BvC#)$ZSs$oS^d>l+ zaYnNA^#_?39*O6>G8HTdpTvH2yt`11!=Jy~QVWGTLitmGoQT>o@KPPe)uK*yT@ob9 zIGfh>=?O0x*K@c^m0YDU06uMGcfs?S%5n6g9@_m#o|&FqXrQ?3%|GoQo7m5(9BRoV z;%eoa?#2rGg6sTj*l&fJ4MRxJle&X$HZ{5-WJdW)LFd!QWo)Guf&%(QoXl&Rbbstn zVrf;OC&7us`u5tr}a%2w&)9dv{Qk1=`VZOV2};e-Zcw`G7d?v0t!?GmqNW9rS%6o`os1jTPQ zmuFZwV@rd@#g?fvwe3Xq-1EieFYVAP9!cNRxR_C^fqIpFWiQO+>LeZ%MZ}H-?^yxx z{}YNFCbn!pW^Z`-s~W8OE*Ic&bk2Hdt?ZqT@3Oy5Ti-G@ZN|mYUu>HX%e|*;v!w|D zbM+2%uwM+kSTakJx8RvFZd|-Gx_82ZGWCVif=H1$T61lIKXe(a`IMMzG0liDV!d5n z^WF1%+({OJ9#oYmiErcY#3wve$Z1)fzXWr8tQ6L1cGxJhv>dVl?sXmmF9Ed8r7%DTX<~6j0TA$`vZ5-`358zZ5*BC@!UQsPd+|ZnhFk!#NUJnY# z&Xpa%h;aOuS9fDt%;l*c^qJVE<^w@bM~k@aEk*b@q!B$H#fcDbVuICyCJhzA2iz zy59@Hm;9-INa~dbY2o?;{244cYSK9jkPp5(N!jl)dp}DQ!;u-=7`KUw5F3Mh!L^HO z8>?0@nDYYpLeI>JhHXMqIq>;cS&nfT%No>4o(eGUnjYirH{S_O7PDc}Lj1+e-K4;? z+J9e__PZ!?ivI3K&778}h!j-%Kp2K|@PY1>`jqKA>Sw%I|+bzRwns81vDG{*S z8HqONd>4Da_MI%a3EA7WvX-30q^s5o1`Z$BBX%PDoTAmHnT{@ggjPb?x2-g+hLS#! z(e%c99ei=*(hIZ@aQr2)6OXu>QVka0o(SxQ%JLUebroMS;%8^4v?br-b_a*+Jdr*Z`8vAd^ey0GrgsTej^H7WA0NR>QN!3x z|9QU#^A*m=Ix^D$%B%j~jiPNvddKd2ghD zkZdb46f%&4+c8Z&)`|rOnNohBvW?+A=>+|#p>xtwm;4@8aMh&?t3F_L?cfMCO1bWI z1iB#<{@sw#H}~|#k0)+cvL-8iN(iHPq?J*Ltkw`xb9p8OU|4gFIdleaJR14{Ung8j zevJy+8KW1pWGEn3@5g)1aS+hzD)kW18w;zY)twRYJChC3c2ORXuZfZBw-ND?3L=35&PLB3#Hr+L`-S=`mfphHUK}G{-W4hBU!?$?E`PizCNFMnV{wZ%P zV#f7_U}yt?DOaL44ftS|Hyj_sH(p2U-S@? z(kdXKfOMB4DJ2*vC@GBs0s_)V9Xccx0SN)=lR#S)9l!7R{r>NN z?|W~&d&W59v*%oM%{ABDYp>pWZ5uUgQJE-wX&yN#FgHAo`__QAczCN2F+uY~EE*0mXvH3*r0E z-Q7nc&&_-9tC>@qEf(o_^EbB3TX|2Sm5hwj;AMT5Co;_}nIbdhTe#`y&cu+Jz|WAX zoad@1l!sf;zxMQu9D;Q9K5cSOW!znab)oE=G4C%%7rNh*o69Fz`Q0}xiPQ7ddcQVi zD(vY*?%;+q@-0Em*D8sDpz|iBuGa&K2^HBx%$aW9;Na)yM)onp>(_YD3M!KXZ%(Tl zyx(=&v!~7qasSq<%;y;2!l`DhO)qw`+%@l{YoeDmG)uiSzu8TZ!#ZWih<)a}KMKPt zs!nxOlc<0dKf=^$Aq*|EZn}|p@6bX*KX>GfW+*o2yNnidjScCg!xNs}hUm7>A@waQ z?0s()wBP^PzqG4Z_tJmWpu1k4knS$Vwdw9J4s!Lp(c7wRPkt1j%axUA;rVUpNwyxP z870-KW@JBb>@&UC%a4?g6!(dC%w0wnd^|BIDwISX7(!?)xJ68^e^lWVKGy zAC+vT-ulQL;S?tD>4C5{ugpBnyrjE1Fq$b-P$)?EO#jdDWv!rrtTY@8^3f z#XP;)C{+(n^4ipsrg*XKe6eZYlZbbj-N=f`mgU!cFsCeXRx zcX02Y^i#iMp5>C)7C3h@=kp2Oki1*?%Tx5wPac;@#*Zg$f|V3!@KdMG>H9dX+&oPd zQBpiVe>a4Tlk@cU#_*MroId)_*J=rD3b!8rlm4=qJc^ubQd;^@?q|h5iaWp$b47)> z@`_q0KU~DHxRXj_`PmQykIHH%Kb%QsPK7>eLuT2#^3{+I-)?%#>uzr{n~bMeX4qHT ziypDcNlPueY|jm+{dgOP7WBvOikPh>-aU(o6=!?wH_xK}$sVffB5yuukW%*ySCFtU zbL7AKX6eHtd}5~}AYx^6{Gu1w2e7wQDxWT!CPMkrW~4FYqi8%Khtx{ad~Fa8FtM7o z&{^mDXF!AW)n99r-+9=-?3gQ4lvXKsyTSDq=JAZRe(R6BM2$ZJJp1KZ+E!G1DnPvd zF8-}|84bm@5}ggNSjj00UnUq(TqkDi0{H{aA+Q_p{~ZnF0A7G2T)UtTeee7U z?MI)e7x%XIb88w4ACxA!Vv`FnX>N>B4LNQPOLEnuSB0<~#a)hQ3IY6;{WqoCAAO;( z{O*yCMp}GS5FS!Y?NPt#%bk5MXD-eH$o&&O?`C21{fvD4VY^`$-%XG5@`Fh0fUfgC z)v`sWkF;)oVbPje2+MtPon<`j*1>xJV$^r#E@#KoRj@93USeFZ(JkT7mCpH_cSmW0 zL}_~7{2^zvIhn9UD##lyRgt7 z30;GQIlv!l(K$OBXXp!PI`6^u=d6L;{;7d=_ndJtI=K2%97#Iq4Gyn3kDfS~ldGU8 zjP!x8AQSt>jO$qQ1YIvF{Yk)I|KP z-(T`@YuSjQhhY02=_Rd$0PHg>!!J=^?yVmlMbxdGgb#06PdbxDF1*aoP!xtss?{zr?o<%%>E% z2nH#OLOY=U%KyK!bLvCTD0_=9}{_uG7k!87t+2`vt@T1K1Y}XqW04RN^v~7NAZ2qtK$z zaD3H*zQmrldV*t3bx^*Gdl~wo@4x<4JvX6=wDvaz>(EY)0rx@z9PXdD$uB)W;j#5+ zzRk|-6MbDPLF$TP%6C-_#)5M%G-&TkDgJc##91QmAIqLqKiff;tD|CLUFEJdu60o zxcIe1LF`Tj;A@4eKlu`f-r{Iy_2gtF2NUq!2hA)O*KVzrT~!Q_7kZ)x_}8Lt-t4q> ze6qX8^&#As>d(3pqYqy0;Xp01Kn20j?C>Di)(?F@Irya!8~%um)7L#VhL<)#&)@}% z-B*3wbA=*Z)b>`AeSp6@kgdF19zw8woGIB@xBq9|?B)cep^2#O8h5R~5dmSoFOW|` zCwBZ{(o%1MG!9hPGM)qc_q{=zfy~C^IX7#_JK7XPvEo}$q{QKLYV+fiF@R|W);KPr{F9L4Lf5N9azGD{lXWy#l1BTu=89XJI zdJZl}RmcqiJx%;gqn*XvH?%{>W#_R`T!8Q6X-mq&a_KbgewitkYU!W#<`pTxZ&MY<=ZKcPr5^rpf>?6u9pGQs^!3`- ziL8uL<~!944L<<| zjmU1PL>%4ns0*;>b^Gl0Q1`=NjSMUxUmtkXZy-`p(uQL3aCEs96>A=pxw9evkz(qu z#^}D}3vHY?PuI*m=ee|I>J$hToaza80unbjO&{exMMqBTO;8e+sl1h)BNHqpL18dz z6l}z>o}1r9E4D?%b6zCGU{}!}Y&AZ5vXI$C)Mnmj8vp#^XM>4x@i7Ba^P+2-t*5yT z1;m55crUCC>+~!Wy$-)0sJfVV2Om!>!td(G-I@rqv!Mqj5xHk7pS!jVI0lvHsk+gw zkut8Rt8{1QeRM#k9#=iqdEWXh{fq8suiAZE99ktxYv(&CkYqxd}oL=G%d=ile zyRaYOG|K7ETxdvtrTfxAjl$4}-UgD3$}2ZS9Lq2suX%rHqs!gN_Pk83+?BMvO;H{2 z$?olh7?^MLg1<)(`WXOK;-P+s0SY+*{gLkw?l0hSb@Lq>0%dRteF_`;j=MJk@dW;^ ze7i36o%TdD_ncBl{uaW$Asm4~Jwu^LYS7$~(x=F3IGugy8d;6zj-dSA&$*fkp(Y9` z7zD}NpimW3kp7xeR6!9WcNdcLgu>lWNb|DadJ9P)8v2k_od_h?e2SuRfb<8PA_ri5 zzK22aEYaM@Gaz|2guC@LWGD3T1BNIlo(T$x*n+|d(A;~WFeD_SsRV_8Kp^HI9Y}jL zcZL{9pV282^m~*pYP^%mJunnQ?0>%0c{1`wz`RRsdxdnN(hYq%;Q;c$@1M?wUX_yI zRh+3ODkf(_=ZK$2HwtKbbu%0q;u>82Ha!j20p*U}!j1dWW6leVac)uI60tq~pt;0L zN(=O8F;K8bOsTS4sr^vl+tC%S-O=Yh`{ESS02XK(Fu@Ux_jUbN(J59Q<@FrI``?YR zC(Jzgc;5;@IzKW_oY>VQrn8)m+te>m?efvl+gx>&^KtOWV=(LNrT4i=lsz`a{BU>3 z#X>HzFI2Sbk!z@)f+LP&zRAXZqU5D5tm*Sp`zGFEVuS_@9WItwb=A(r3H5?GST5^_ zEHaa#7haB_bkA|9dYHK@__@=1p=D^~#_t@tY#|zB7 zqoL2eRa-AEi@EX0YOJnYyW#cHMEPw{Tsk6+@*?TG8NmzdHo}7iG(2X3_cDY(@(^zm zHrl$p7SR1p_pEgKNl9(@E|F@<$+>#W8$2O&%SqShDfQme=5F-Nvk!JsS<)E2aTgTb zdOO{HT0Yq$f_J5QC)Bm<6=TfI*EfV$!p%)El;(} z=6+Pu7xFUaX>T6cR1@0^wU4_JizfVNerJo$jbe335$xxT-k2{;AyyOJmeH|KrWf@~ zRU@$aD#DU=`Gw~o3-$*xgc~n(PT|W!%AkN8Jx!hlj65^dAf3uo^F`?{tzt1#Kl{WC zrI8@_jjJ)Lq#}>Mvg|PuhZpd;;mwU7rHFKy9dF654@ye#BZ~bvHY2B#pH^{1yS=NF zQlBOeSHvCAvX)nS&0govRld(*_dQU0xn1O2J{=>K_LVN$$4@>bk?nrl!58T6W|kVg zO&~=3_WOf_3wFkD_G6L|`K`-%g-J>$3D}3V*F&PEuD8899O0f&ay2+F(sU*CoSt|i z>zfXhsNgR?X7)z%3w1A(Ay*HPPj z$@0;j`70(@WhSggyzv=4fjl%$8#QN3&Tw&M`G)owWtxrnsrg_CrL8RBf_2%p07`af z(eKave6pdi*LGvo8=Ky^tP>RlC-A(1^6UA1#+i?HDA{%K2d74)3Js8-eDAXm#YiNcY46kaRWBL)-ExAz_xjhbT!lr!go=fNJ-p4VSz&`Ko z$9*O7?S1NnM0MO0v8)IO#Fs6_jCaeA!_RV{uT~$EgktMUV{v<^&)vQ$F1vVNvUWNR@$JJ8dn*__ zximg35@nS()hcS4lXO|rtI?XcEC#DZW`mkFMfs|e|4KMJwXY7x|%h)t^ZY|%+;*eVpfPCpKrKeNN6Y8t0^%5y@SoUvT z$4ge>+c?sz?0zu4FMONgX>L+ZEI}36@K>siKZay5__Gfhv~SW63bK)fYs!jO&$uJ; z5biv1!hi;H0124T-H{(pki^nZyHSHe2JS%Z3lxtGK5r!jZkLQDpmwYtg_2i-*)+j|3iiQZ{ zZy?+S;d5Bxg&=+##Ls}*C-qZg3EbY1mP2~w(cN|7_S7E>9f3MHLA}DoK%jPyQ3H5T zJGpa;D#3v8_!On|1JVoG$_?k&3qEIsv<}h(oih`p3$=%d2t-*6WT!A1qW?K0ABu3# zOGR{}+OY)a2Pc1^GzE#ruX#-&s}~u-z+w!hfxp3h{3m|`zXCZxW5EpYJ}AD-#l`?t zswO}mC(j@+BdDh&^AGDLw@?yaeGbePb5V9++-fqC zAMU%vR){Y>?c>y2H%yBbu2@w`Bv&?xcy9>SCRAm3oY@0Q=0=CQV+4e_j9Gdc$wuniCa z>P>(bweDc;mh-JW^AjbJ@mc25bjF!O+ZEMFSP6ECCW^e8cGcxp>qr(_tA44&yZR)4 zFHQ>~%6jx-8BBful(t3%nxkv4!W~=Zjkp-rNX@g?FFn&HEFZ>QtHV6O`R+$5ujd=NUw4J# z)DD$xi(EQ2di;DEFF~*=xa=%{-bQ;4@}zLG`gs4$meeaUx2b)85ufwXk{41Y>txOa z=_UC*GFvaqaY%MN3ePl|H@EgN3{JOwR+;UmYs`23DVFyO_u;Ei9F}+_s_}J92DiTu zMW`5N=zD$rJmV)^Nb!>3rHbUYo0SJi30moUz(2gc^maMY@m~N9aL0<1!^-Zm8TErZ zausY56DR_#;jWm{&VT1`5dUuk<()4vEdWJFyLNsds;3vLLF|=N_XVTFA#hs}pdJV9 z2e|K`oCAJooruOp;+}u-ogYR0-wEGX#=aN~ZI(#{azGD2pyzJ{1AB+b23!{!4~Ktx zZozYWmA&m&BCE%>mTRXTeFoQbfj-b)7+P}r?+HJv2hTgeubC26T?{)CSL*oMspOuy zJ5Yp9v~%V1|D7(VKY(5k|8L}j1+=I3C{e;0o0eX)Ziw@vXKA_IdXWj41%z9Sx7_c& zy?#7jO^Dd43KPl`K0pbRWEifRy+nTYJRw-@Do13$VF&dXKsrjOK80orz{G%@3zhrN zbF6?p|AYomo%{2gur#!4L@G~TT3E|#93XN}A(cD=Sp>`+#1c?ZN!mZKW$qOO+-U(9D5Q-Ob ziV}y@!#IG_$3`K|2%z?4^8}^d2%X0zhK@L}g5rgsyC=Zy+EZBG3>t}`LQ$x0cwF_q z53&ntR7c~XboJ5P?;s&NJP_`da65!U2(@FIr^vh!C|$Nw6tO839*J<*hv@})+y?qx zZkOz)(CuZiZ2F~cGhqg*=Y16#NVq+F3{Xzl&2OvoWg?%!NaC$FUK}jmy&wKJZqTB2 z@6_-q5`pa_|Kx52NGF+!V$Ch0qzX$EvcCy|0QV7KsA{(Vrwx;V9QSW{cf-)aEt_1a zU3V5Z3g$Se^9?%GlZACNvU&sraC|1kSguPmIaSd(V3GwSU0PtLwLV+v44zwJd8ji$ zKXYzsk=Gj~R9a_nOt*rReY@dL!Y%4&PJib0LHOSY28w{cCiTMo zrw(P_vvfakq+bN;(I60BJ@U}g0r~m$oWM_98?3$l6YrRpYy8AVQop}pTxw zR}EXgIj^=s2#EQwu@+_nw1nvwFoOQP6HG_J=mjIFsDVS3U_RLJ|0|Oa&jsek!+06S zUzvxl^oAlmV{|r7(qUObN}||f95?{ z*}s6$|Iq*cBI>_n1^+MB7YOSE`3Cqe6aNpG0kA%B9{~ObQU9fg-~ZzL`oQ|Y`W?W3 znfQOe^!m#_;6G4qFkl^+FoN+M7EFWrv`&}?2$TP1@PO^{gAECW69ngZ0sFxF!Qfo3 zK41`>B9Qwp8}L6O+<<<6sDIKI0^1h~V7Z4=R0K+59R==ZEX;2>_?(A=)8M`C4VVV|j1OQs9)9l|_v!EW`LMq~!!#(TD=-b- zH)p*W{3~BTA1_QZ!}A7a>*==0KK`I_w%_lkd%^S}JfEOm4E4M2pd)ODp>tQ+F%Zx4 zp?(r{J}TI-1~7;N8t)GsquxMaKj$3+VLcsY(E%z`l+#vB-PVf+AN9*p@g7Qk2tV-bwSFqXgw?971s zrD$+}IT!Aaql;s>BO8yA8|6?xS`O+*=Ry5irBmd2cwJ-D5V{{RDC8UHkA$vYra=8& z%~Mo5e4a0^E)@PAg}fU3JDeKs&sRZx52%}vE*({qy3nQ>g5T?ao z)cz|x;RKq;K}SPi_Ce|JqLAtEdJX#l)W3!5u8UBEkMc*M^3))^GEPyK;PMp%pA#Hv z5B2{8PEayKkbRs8_d3`uAuXF?=sSUDA z=oEEt6v{Un3W?{zkV`0sC&dF+}I=NSd2{Sd&vf8*crKzj!e z*a_tRj{kS~-}ev1!-NF^{ZDcroEj+p2L$^5As9jTPXRC=qytd$FFxo${J%Y3`~kOD zo3MQ(Mo5OAm-}gVe+|)a1cXk1(sdeIVLx$Go3`mErW@z}8mdia8yozj`@P3keKLG##Rvuz^a0Y&6^{!(`^iM=xkS+g- zSar4$KQZqbwe(L!Tb7&riQ<=s=YL|4`a!}^1bzYdqLk=YQPO;GdiiH~0OK*!Pdu<8 zN&AT|QN&3-<|i_gheNv_5Qq(@ zM(E*q&9FR7{v*u4{v8wxOMne(U>^FHlcBJ?aJVCkAu#@OK6H(O=?gGIU4vi0UpEE1 z0>ivIm~RW?ubTy3=fU(f7(qSy>n1`xaG#dpa5)%%-CXEe9HuYBI1J;jn+{#~z_dDy z2QVhUI0*X@qyrG})yjUaa8gKS!7+XVkn@JQ|K0lFzgw>VC*%Gb1jrXaph^+G00{X1 zgdjc%EMNp95=I6X_hJ0?utC?Ly!~n{AR3fM0a#85#$SyHbPdXt2F%xj@mJ#lUH_?H zVgB!@34v&WX{gKl>t_sOE{wk#Bj|b>rolWTko(n0L1F!HI4B3>Fbx_n&`$Bd{2wra z`9%=U1@i%Lf(sZq{-W9cqS^kU|18|Xd=?lnU<7^z{=xn$K6q{c`+u&T5Qx9~Ge9qp z2l)atC=Y-J`2V%`3D^bf1@$19=l?q#$o)G6{uauTSP!`-BU&uPRFTGBOULf%t5nC? zGZisL)bp(AJ-wOMj>8_(4Ll}@-F3D_2Gui}%Xb;udZ*9f0X@Ep%Wh0jp(&k33a>aP z8jqx72Q3zToNbuVhMk8K%(DUC1X}S`*HH`p!9C~c94f9E@EQM}`q0ZEke`tzDXE?; z|4+}$1!wl#Or?Z<A&3vw zuK*3=0UG!l@c*j_^bo-pnm$VYW^1)=ad^d-qfswNVwDB;l4!fnve!3t;x-_e0lyb3 z*NXh{B(p7BnOy>HA_YFL9KF=hVrGhWV0oa%@R;!#{n))LL2TT2PHj?(rvCEkrpzmqOmI*1birY7H zSXd=JaQW)5VLe;ju6X79uRhIBlNBOtOEYP{Kl#{Z!XiLK$|jO6*M5UJp+VP;BFk)! z;m(+$eQwW+ge#~&@`?B;o)3z&bKWf*d6rs>^T|g!#lwIw@0m8G#W=Ss9^ltb>yXs4 z>swn1ejSUccvb|;qnkNH%Dc<2^>R=Xr4fA>1d5W4b&ZCD;n@YLeA>KQiFp>DpxuFvJd}Ac)QJb?dj~EP`hWeXht4~@ z;Xulma02cp;2TYRCahZ190&A&6*(g%l^+BI5ebuI`-HZ14x6sWog}TA41(ulum&$g zR``wqcrQe0g)z;VTwl3Fd&@*TZ_5nuy^_!Rt3PJb(;6wdX|R4eB~zV9+g}lkg(H(f zq0l+^Y>o57d9n9Nd_Zs0on1$^{*S|r4%qG*Uz~>y<1a?;VD#g@zQ+B@fVrq-k@3|W z^!cUS&=8l$9Ao9hk<|8S$c5-a83+?wmpZmsgaJoa;^uJrVe> zp@3r2IoyEYf{`mvtg(4LF9Sa5$GhdP!`(kDqmywbT-PHaBbp?8{%vht;?1z@gY2)L z&5yh2DKHlrjSpO2D|uCjX@(PGO)^z@aB*%Jbb4VPfal}itykmU=X*V6RROvOi2v^T zwRX_Qoaw0O1Mqy*lw6_|(o0C@;AnlIa925`e>3*Z z^WJD0muj`&=w^{u4IO^0?s%<(t8x8P-YOBx_0D~tB4SA^We;Y(ugENG(Mb4qAo#Y` zacL|9E+|VDe{Joe7kN!<;#zirvhWb|l6JS`TZfN)iUYyw3{0T>1Al)1%zA^9to~BW zP12RO)4q)7)0n)^OB?TX~_+A=Z;m!II`fc<@XKl51S%gkHk>N>Y!fH;ulTd-<7qt`igZqn5f&7 z{<{L>j}oIH&_3yHDKMPhN+6wULu;#Bl=!08B91nFRtX=}-&QCzQPB$u~qcB%Xm>)ov{(t6L%NpPE_B_xI%v0qiN zVyNc~7uxaN&AV6r@PQwV^A`{N^3)^_-0=fZ?BG-T?Wm7u>B@g_kAQNV-dDX$)nseu zOU`Dz8b5n9w`3cv{*)jDv|s+ZdXLVs{}9}X3UAM-Q)|ECK%&y6#=WtAo$=y=k&lSx z($&~juXlIDn+^2LOUqN4Feo1KQDi+1h#{Kn5*jU9|K=5u5LSB|j1v$aBC6K8zP6VX z=o`;qKc1^uKQ)tWu!wvu#u_pcnaorEJnj9nA4Q#_aR<`{z72HTD`Cztg0Xo`$y=PF zx2y(Iix|Xw>_v;O>YOroZ4=t3;$JjSif{WEx+C*;VXwNSj!>~yN`vA~YKrP;*SX^! z;+;FTOxe$Ti|3&U@ftzHuqqj~eLjXJ{pHH0L;{w>1-QyF@a}M??a_OH`n0t*@%0_hV;(}2eqHmyz=!`@unBrBg!xmAHTG5Rzl|{ zVG5EZ9l_GQdHt_Nn1qaQIXZQU`cROTa^9By2U_TE#C9m>NUHY{svhi<{Fv9Wa$L|v zs_=0ls&(Kb^@E|5`;`mIkFNz|h-=;tblv(Q7JbH;K;)%#%pJ9_cnze(iBnmOiawtu z&o-pdPa=imRHdtWZb!&OpYV_RU`Wu(IoV~}ww>;r+C0R*SJj6*E-QZO!;mh2MvuWv z-SwttLnu?hbMH&-ElHgA%#!A44XLChj~oO9=Pc-O&(0{FxkuD;q&cV=rNNK9AFWts zfNz(89v&gIK8$wn7Dq~gNW4;V*Bxq;rR(oQcDpG~TVyy?GlZ?iUK*9l^h$?3m=X2Q z2pQ0EEZ+&yy2q-cCK~r%L=J!2Vz%n>gZvvv70Zx3q6BMHwXP$FYY>&4Yzp2UssNW{ z4~$dh(wq0J=-65RuD8H*=^!C6$oD?{%HQFC(_8bh-y8OYx^%TdpE<4M(17r3YQCi& z$#$Rm&Fsn-Io-#b;Q(S7{V1+ZE733t+*kVijk{wpM%1yywW))h&pNcINwE=~B8n}^ zSGWJl^2oJhek;=1JVdC%rB7npB#inaCfsJj$@X@i*AC6Y;ydymWjOEnZfpu;+&+j? z2(2t&cK1)2Q2k{0B-4iT>aqyBUMC0lW6LF6in#VoKcPu^o4eZ4OlG%XI}+9^)_O&f zk^wfT+^Cf>-I4(L_;(28!@rJ{`94Iy+S8xwr^rotTCn2DRdQi#&mo}WaQ|vbxxuGS zk@neiQ5<#MYQd-YB3&9NyqqQOYws;no_mIocn7**$(J>G$vUoWwdW4+G_lMo8?x%3 z7DVQY=~4G@*y_dz5!M(wyJE|!iCufKFSIdVch)m5>ex1J(qWw8Qf*_}#!hGS!;*L6 zpGN}F?p-sflD3x;HxugUi?(^y98 zD*Vo#ln8m$;$rA)sMf?){hywHP)=_Chvn*M?5I!^<*E07y5Ig!&p)U?z`~!vfMXfK znLs5yy2h2pCf-$0uKrVWvIr%ZJH>ANPvwE!G|x$W)Y}z8P1nmWys9*xD=u&PVBW>U z#~o|cqEo?&2llynJl_tSSg&%Z@;0m@UIN`Apyq!YhUHIuw^PYdyN(q(jJ&Nz5Up2p zaK1WBqckb4bE!FZ8?;-dt~gzyw5PHmUCg(#F5E4y|kF%&cviRoNR=kgfx?pYg@d8)(3e#BkYNjdb; z$JO)WQVxD}QaPGw6+=mgLx~r%L&#dwNuvm)?`P(EsdeLm51>N{8oPN+hE)L_m51dN z`{@-6pc9quFrQJse+X`*JvM=D3xrKh~!-4uA(gX!Vq-! zQ3!cbIfS>&ekJNosY)~AV;=>6A7;S4${(tE{+6JUw6W)eP9 zTae;frJqJ*T)%+!kf79U=x~Nxj3*rFEU<$)A(48Uw}I4`>_qQ?U(ux(}D+mjweZZR*XR2l>jC5hgqIA?tPP3u!0kJwFX_X*&1H z4XYc1k@fj%b%ZsgEk8`(G^8}{Y{rKqwa_=?QNj6AMVq@eRdJ^0-e(gtOdM0ynDV+o zj#2ZuBYnz#QOm`cHy0<8Ol2Rs-p_b5t2;lJaVdZ}&Et;NqHO;F&7#R7=Zn+VWZZd0 z>-RZ)vfi;~eILF~@$LP`ND;~~dtVlc>lE}CII0p4ho?iVH#}D2$xKN|dvfgDHv-TY zBqGy&pXqW~?Y;{pP_3W2Vk{p^*=NhD&@eNTGGr(aKJeb6&E0F+>;S!61j^NKDHD>mJE1>`PPV zVji@eA8y)wolC*1wrIKH6Fv9PuF14jH21j{FCWj>hMN!LCxcb#F~x4*%6Dz`v9ODA zD-`IWCca;Cg}H>yp+wWb!@7iRhK$drSU4nvC~_b%wxD42cI;R7j}D?=Vi8GEE$`Wn z+pzFsr7*)?S*m>dPQG%zAECF0_N9 z{P5$#EbU@+O-B|2O}TJRF{}FKy?e_fXY}}_(0aBWbFw+q$r~RhwTiEW`Xkh~lNr+w zU#{&g@(a~YSGbY9V|pxWvzc{CG5(2O+s$uVPmH-<^#q=Ow-J7E*^1+ua#+Q4DAn(^3af~E!o%pg=_3Y;Bu+wMCp^H<=gySkVoG>_g zde-}@>HILDCGs<6UDq;uXg=u^JXrhcJ}TFV9+kEFC@hp;L6hewvpP#f0@QEO(jSe< zNX0p1Ippo z2dnSf7FM#`@w?L2LYH0uRJ0R((H(MX%2FUT&hmuTnJskac#O)saY2#Mrw2S!d-+aV9{xBJ*%sBfKfnx7FOc|{$0>O6J>?c5WO@q14PI5^Hc z!nRwXq8kz2Wn#}dHKBe)@ulMX)KlVh!JtG%KsoNKPRr@%g`FB)8ylAk0%y8`e$ zj-{2KBMXZb6OjfjMwMw=SsKoC{i2~}r z9HU0Z6uV2QYz`_3m246m=Q*?zC_H&Q#8a0<&x=`?EMr%Sp)Pfq zt(rqWNP+4F58d{1CD8wDZ@i7JmGwn_>8^-nN^dI@zEQ-@rEcpX(x|kx);)fn%vUfjdyX$#SY5=uF^?$k`h?=#RPy2MK}%-}vSa+I%|0 zeeTN_k2D3fQ^9P7I_8X%zMJd21+E9oiL?Y9iyOP)+j(l7|E{ByM! z%4*;rjax^DY-mS0P~>&8LSb=7w6Ld)BJ&at9x&x;dzJei=bm*o*I}O z`FJmrYj4Kt1i2Fz=a|q(?pAO+$_TrzPsLm^U^A@G2)l}7@b$cQW&pLRb?uwCo664b z-f$-9yVMo-4w-(vM-DnhD~FTr_?~@#`Y)h7{Ee%y9N=HECvazTFOrfv{T&}nWN2GA znZA$r+IXcc`RSc)t{lLB*MC@j>+y7CiCxV%xS4!hY+#n>RpHd-!2UISnI#rwtB(8m z=LVT36Bm|(-RSk-2U3k-URuolko`)?g=g!7WrYx}t(aH!HyX@0uVsH*#Yp~FA{?>jvmS=Udl`KAAv87A^kyV?xBuzGRJm<Pv z1BOeI=I_hkDi4xbM~zKd@`@$fjQbT-Db4!S-l9KS6wrm}KcFMOf4a+6^SC2YvdL{- zVr2;Lihu0%g>z`zJ}37--JQH5$Rp$}a%8nKbamHj{^K}l=9@@{Begqz3b^N`y;8i2 ziW`|qxK{2GZN57><0ph%d8LeXw!{w`LDSaEV}Y>VBxL+>fLiVIVZW1g`^on1WK2Tv zOMMyE;HI`{q3&d!DDSv)3qouvt}&nE1K4#RmpNZoZ%1yz;J4mGk*>fwsEB0dFTBZB#E4!b!oZhE@u^jbd7U(TqeI<~`IyVpv061MBtF{6i%RyzpHeu>O8I9?tbfg_rCKB?VB&6#Ec}bBLea#>qjqn67%KH zy*(JZD^h-aB*!;m;G@sSdKtJ0JA)Va{)( zQH^27MtB#5$xRjcRQTeph9{f8bV6^F{)Xw<)ObOE@vwC1u}`qeL}&C(yuiA&HH&&) z+$*~UqnK0!(F4w8q9YE`Ovy*%uCt914Hs4N`*4_q)|}i^d~hCZn?9Cu7v8pbcTkGq zWD>@LomNPCuS)PKqpqBO-IJ$|G%fTCSTk!@EO*n$(0M)PYN?F`Sq#r|nKUl?CB1A8 z;0(?CtZMz~Rotm}(y0(N-u4?T=BO@J?pIXOmT_@=FO2}dHI>O#PLY} zxmI$0(Fga5OuYsiq?m9VnnAhAGp-_18u@YKU@_*bh(HV4UBv@#e}?X3Pd4@i$FZSv z7W&0a-)7ozDO`qG;)KS^eB$|h75Wqo5~h2Qc|N7x)(Q0J-$O2)yu9T(SVAcsKhzpP z$1O8lc=hu@uIRKL4J$g{ZM1zUmUFBX7TnZ$=v*xiq;HmNpmLYx_OyeN<$C7P1?Z(` z=zVW?AjHX{E56B3lYCD4wnRk5ZPlt^zq|V^EZxg@d8*>e54|S-i3cgpFKLs|MV6z4 zP?W~F->mLq>-j#D7iMQ+ePFO^LfKjx&(`z##Z-=^pzO_zM2t0s4Vw>|T(6M}c9o)S zZXJQR+b#@EE9yascoeIoqjmBwtPbw@v~2OZI%n48iccK182G<53b+e9eb0YcRBo}` z64EEL(AzdFYq7<@GbO(9Oe0J3WJkCAwo$r@OLW+mQTlq>3w>zCn;n5)a;#fuuJJ2q zRZmIQk|ncf&f+Gp3Kg`^=}?-NO{e4+k)ZW-u!n@t8fQ;QM+}_3&eRZOS4_(E(6m(b z<20#j=)Cgq;hdlGTQ6?+dwU85dKYpA-LMZ?U#>IBbkF9=BuS9yrt0^-3VoEpcSqmfw7G+RARK6`cF%_ArM1YiHr@8HchG43H|eJa!wr@-pZL;R z>Mgz+^GqSra#lSit(<|3ICLRWg0(IU{iEE-ocEvZGe%tp?b}6f&1=&8dqGNq0;`Ub zGE&}O-KjnE8MbnISRXP?uJe6m3=Df%-(f~iLayGBfg7R9y&kwRKUPs+=H#46;7gnI zwra_0SJWh1vgu00_Jwmu^fghB2VJ{ewOp<uw z2SxRPdo6F~v63|K@%;*g*9cNH3^s$r!jy{tv%Jq!Ug24V+gq_kiyE8F{!(@@jd4sm4o3g93ny14CCcs~om3O5+ zsdSKA6Fd3GWsTwH$XTiTK4LVhG52Tf(;V`h=lVXXW~TXgm2uhqO?Hsu-B%e4YrZaP z!3sjN7beq5LvH>E{+#|Wn`~LMXqF}>hrCH>X8bkJ^Sg!*s9Hwq#bQp_`;KGuUmTH< zU3}(tH-6BZKipZG7+Xi=4Q2m2k&E(c*R+*O{8AQkGh6uQlTEk#sr5tg9w=Ihmx+$w z;CnHeq#{OnVJ7_kEc;-O@Dq%u9vOK|nq9MJba>wPA;n)lR)3ciFnWQ;x}DTBKvFMu zzdYU0JwlnGF--5X@?9F4F!C!z3>+MLq?jIAb7couN)eUIu1!}>wH8w}#x4+-TBKtM zqqSkNc0@ikI7UOi2+ED~$GY!l&gZbw2Gj(zC8{N#eK~zK&~ya*`dQBIyX!$)UOv)C z)TZsVWSfs1hrSoq2;cXcW5Z~B+lAYUQC&cr?&p?uP57Hnnk0KGoA%UlY6`YImWlgi zCseDVkOAWhUcy8a<56AenWSh|;&GW*l1iWL+ENu95*VakJz6#JPk1#_6xS;uzIDN; zU&2V^njp0b1K~b?-dO_bug;!)JQ^e&K{p~VQ27i!bK|pk8Rf@vVoElo(t#-8L=UnxH~VSLYzRhQ!Cbj`>y+?q99Qan(%JaMN4GSK&7_NF z`N=X1I(NdS+K>Y_nQ@HYXhozGA{j#l7F7~$XEhS>%SW--{)i+sch8bZu zo6`EuKX%SG&&aQNHjgHx!$mJ>Z)(|s95>iyttpB33^!`aB7P9tgRf1!Q{EpD=bL7l zaGOu*tkC&2pOm}^yH!Li-s?dmkKm<5%t^idOY_2xBl_=YnM2BayJX)5cv?iNf26uC zr=q&lh>3NLszU2=om+*3hJ)u<3ZcAY+cI?H!k&pKFh01U=TLVc<^zf3)LJ$687lv1 zZ@DVVs$r8sO$GBVap{^BS{~KL{$k_XP0gQ^b89i|eIlpVulw6dO?Q@m^l@l?%4Q-> zi7LEtd79A3a?|yE$AXl>6Ne0H5Wd_hT<(JJEnSF)X1f?~lkmM!&BoqIC}Z8`p6^q8 zMf>kFW6|Dfd=pJ@g?3&_NxMbrJ=F#+vdsLnA_GTV)qIu4sSDJ1n^&$?H{{|Dk&<+} zad$rl+u;y<`Stc5A|V6*tYWNZq#OV2(`Xe*bi`R0@F{87(qiT^%?El)Y`FKWe*_;l zC)uV}aOZ>JDuP4oGqH&pvG1_g&bQmVyMOd#EEv|XSW`1BJh8tz#V1+{^tAbn6n{6h zN8gg&bF&ce1k(VBiyruw3O(xDFqj?NP=f7GfV_T#;91@3(q%H71EN>g2&)0#aAZ@f zAxfD=@Fj|j8NbzQnzh0SaTXS<sDojAlQc_>Nef)L;E$&&5d({}?5k@nULw0qbsfPY%j8+!Uap;taoM1C(V?T?-P*o`U7`fm?vwafZ` zP=*Eqc^+J^u)QHg0nQ%eje{G;Q-JT8#<~CagK2f2U+zg_0sWtOcP+zqFaOc^eZ)wD zm~j@5L?ADJbeDv{>>+E%G@AYJ7jCdk8bNolGk8?&=15~khy9b+vVYd6yUd%ADr7tc zY7t>>Ij>j1YXk@z_Hz_S{czLAL^xA7f_DGpYo1&!QuXCjl%{OL%R~_gFlg zMrBWIO39kjd>!Tm_V`_hoi%nE(flCMZ7n(ZdLHl_MY0vx?w)wmTvn(Wni>}deA0Wx z?oAg*8GF!rF$`yD;kPWH??i~1FbY-7U{257ySqF4WCh57NJL-i!O*{})ifScoj7{&r7Q{8ZhtWguG^00L!WfpBjQnYgq;1=bY8Y!NrxkcOs#=m~dG#T5VTJjBl+Q6OjK|~}(waCZ z&4#Z06Ci)d&#wB(bw>;t(hMQO)>nV(4ck{EYd#vXF7+K_i*N6*{{Zsn+p_)JO1PO- zO!s2dJQ%<>3WUKEm4v{v8Sn1i;o%`rTpI%Nj(zdXgkLZ@;@!7nTHkrG1O6Io2Pr<@ zYS{}!G3NvKy$^sd_*N;*Jzk_qlUdhh!=?9+{B(3&-u9;$;iH;3c~0KhP9Tq6OtQ2X zKBEvMb8m`~^3)jcaWzC7>*JNtvgd-|(Y|?^4fq1IBUgy`ajP7#>7JT#6oP3mgeiu( zJwC!DMm)sCoKWM55s;U-CE3g0Vc<2tF5~G~B!>?8E9{S6b5h^P0W?^b`yiHsuAm(E z;?An?4;xQ&EqhOverJKi`-0IJg+5ldG|6X(o{c@U~Oxv@X$uP z^A9$rAEX(u!oqSVS?Z|ISB&T$;;^VYJ7>g5#q1Or9-nU_F6;Xcam+?0$@h%G8f$y> z5~lEJ@}GJR*zsTpU36pR|hf=s%hMY*$k-eM_j>54@+3I zNzmcEUmWd!wL$a%?`W`gekDes=$U7}mY}rb&UDECMcZ3O<+Uv9!nnJ;LvRTiAXspB zCwOpocPF^J1`F=)?w;W8PH?+9YiF);?;3ZHeZG6f_x|7+T~%FO)jhlE*;4avZ;Fxs zI$vBN^3cgV!vArwUL?QnZk*WRzg9xKoWx}G@WK4pL!a$w6C{1I2FWu7K8CZXJEGyu@fk~ zjy!w9+p&Td$n8G`;L zEn=wa&9rXn#78C5&AH0$?ay8Zxf$L!ZuaD3FI3FqH0uDIIq*(z)VeQ%c`k}{~ z5vVC+d1vbUq6=e1Rt)BD)!}vv^Sh-ZahL2d=G=^m_HW(osmmVUj^0E+TLh7&^9s+S z=SRY#iO6Z!bC;6%5UsdP^3DB#7*|S>G5xlF3sa@sW5o1iTX-p}T!HPvd#CTVwmR`M z9e1FKVdT&qBIG(LT~sSu&RVf|Aj-4Kr>e@W= zS85s}qEyL1^SR-r{AmF7GVg`7dDZp7VA`YVh!8t_!{)8&$>T?_|JRC4*#?sq@Am8A z#T0$68RZg`OD4ZA%EZwNkk@(eJ&Pj_-BQGiy{|@d6j5=luW|YwFY${y;ZWJsju@oo zmK*F8va3$pZ*msOWrkrN)TG-xQA?zsgpPMZ1HYCFPa)B{H_0n9Tl-1aD|)kgK|U#Y zTEJ$)5~0qDURraJT;JYO=33xfw{X~pJF$px?B&hPsCY5!_jiLGXI_?OPIXO&Y2UFT zy8SRSk%kKfOM-8Kvgds7Y-l?i6WL&Hy~C+=Jf1$lJU>RL0q?9?((-8MLS2v;pYE@z z_~_B}Q{<7&3^{6O@?w+Bn$1IZS|iD zq|FMRy~Sq{o`h!i^nIftOI>_a&&9X#P}dw1bSn+_jCpG2noR~ka6@x*4y-S}eURN5bxu|0dHDh#l z3zyp3>5~AtX6(2a!ewo> zscn4c+tuKd@hGf0GB+njPv)FMOa%+b?C(i|3r|*M`b$U*l8>GA=ieX7J~55@qAOo` zn8#5#9)3o{qARdly;dg~-&+;RT_~g}-kNgjqrcuT08Z)G^csB;`t+@oKz3|dQ|WWicu9&0|>*%5Rgh_?xwiSTkGrp^Tqe4p%?8m!tY)Mi^jF!)}v z(I=Lwa*+1k*Ei)Jb~?G`lL9%cyyU`{rZU|}t{~ALMhT&=NjNth898)wO4DPWQ?G5} zaHm*?dwx3?A5)-szCN@?yg&3_4i$5Qbf3HNq3kINXN zp3Ejq{-=H`$D;Iu64wX=kb79daiCEcsbZ7B9=NI>h8mHtH| zR^$SXZ=)5t0Fv;G*PHB^X5n*lB*uCLhRmy&r&TImmQ+MpL`#1=n1Ey*tJl)z-_)`& zhcFYZ+aN^1BVd`&?HY||E8{f;$<4z68qQvQm3m7G9-3e#Mex1+d`ODkD}q!O<&d}g zpx5PA@d}a{TYa_RQiAlxO52blHbAy@ho&Jejg3snZ<6`(R~?9ls$bEfIHu8Htgj>t z7!6wZk2)(@uitxn;Oj3ls+J~}c6TrmXjWI(L9As{ZDiP!MOui3i}|nS?1=q+YL^4M zERxim11&G)^VA<##f2~09@yX=2@M?X#g3cDtira~&4pwZQ+r_7cJB}AEYkl|{RY-l z(;R9sGQO=cK-kx@?UP%<3W+O!; zP#7Sd+7WR_c>{|Z+xiK3&b&3xxil-P)CGOl4qe=@|DLx4d;mFy zCWy)F%37mWKigdkkt6~1|1M@}r^J6N&ing4YrXcST~J4s2=mX(8Fq@+yUc%|figxL zF+=9{DW=vpa8$Z^7z74tepdUkq8UvQJ#!k4Fm}l2+o`vMy3n?S@r2Yi!@`f!5lDw) zFvbgQngqQz6h@>ab?U|L`i2dHA7+J`7Ci2#+aXgQ&L!df7n};7h^$rpp7mNwp&}(S z7tQ<}dG80~(t2opYJ)f`9p|4_E4v!Bmo6*n5>6V(+ocNg#`6^;2 zRs%ooH0AZwvA1&Zp6L2-Sdjdh=6&2j_WwTn905L>g_=CR)NM4|xkd&Ct+8V}z7r00 zPV`Y-8Px6!{AKgA{pEo>GHbT9SW5zbTXa%85<01ci2ccr$tsQ*aZ}Q zTDB9%a}5_d>?)e z*$iWu`##Qk?mW^Bw9DEpcz#dPgRMLfFoB8lL#}_LbsqPYR8;nPUqlX`pE??4%gQ!0 zaO)4sRW<91%(?1pwD^pB)PE~4@J46iFzo1>ldD0gr__WHE^&5It4(Q{(lWG;>2No( z64F+F1g^1KGVpZVNS`^T$1eEpgr~XjROCI+NZRV@o(`2JjH38>etC#fv|R`(yl0kF zVNj8AsV@CaEGOSZZKWri868KHxCMdTY&3Rr9zTa@Xv~bL#RiTEW!91+ni>dPVT~kJ z#au};FT=dAD{O6nAG^Ny#GHUx33DYJD>@e9#DhQKxLsqlVtsZ(|i)(xR@!>LTtScJ3QDZpz8g|qDyPm6;A(U zUCrwxCUCNvXRtjI@}@*w6tsp(L14;`$H=aE$DJi+fRvZa-Dfy*Z8vJnWKWIjc7XXx zzjLr%;YadVxHxW+Id{o*%sG6+39O>LWC$vf!D??0QQQ409Yb5a@28u<9oC?C6iXpK z=EY@ov*hDgAH*%M9v$+~5}LIjcBo5^*@-Mx6-=T`9locM7PYRB+X;{0-Kg{DC(LHV z5nN1JDi|)w;FMnfO0wk6Se~^Nt31l#alDB1)GrrU^5J+ZO$~wf+OWGCZ|0)Gt6UB& zR+wms8bU>mLO`%?ct5X;Aq7f0Z7Zjmb7(sfzQlCOa?UWYITByrP((XfAq7`(Iw{aG zgcQ!nt`s6(wMyUA?ChV}=Z=&VXQ=1%HC#1ym3?UGeP|&Cs-`(NQ!gSc5`Ihr1t?uJ zqCa;YaSrqyhZ^r=p6##ct$e)EANQx%$wP_)7=0cxe0e9FsYm>n26N!#X3{TvkSR1X zMiPn8kzZWTxMwVm=az$UbFn@0+o0a74OA+A&LJCo!ut2MRxw zy#I94!39}bBWJFsZKQ+FjF)ZgIfKTQ3N1n5(~QHjlsKM=6V$a{#$K<_bj*7|UWG(B z3e&lY(!y1TxzZ{m87{N7(9h=_ZBzzcXBam9>$P8y29;Y(GK97k529zuhau56gkvKo zy_m@Co9*X=#PTC@%cAIf3fZpJDGU`puO+A6S{vxd)v^uLXF`Hlr-N*S&5R*i!2nA; z!K-6Z{s~2zu2$BvP;QFXYbli~PaS6g$+iI3&rH`@Vz2I>2B7D*ndPJy8nh>#&zQ1z ztiPxfY}}hQXa2pO1oQIt{eyL`ZfOXyd8g@M|7%p*BD_1Dc8+0hAM;WWt%VOM1Ff0Y zySJ6*VSIN5B(5Lxv5CT1iMTGEa6G0fxE3nQF4R2$(E+ zMYJ^eP2rJ?WlH3TXmuTQP4CmQCtRPB=4O`YH1F0=E`kwZ6z&@g7}t8+EQ}UQMZ52* zP6@?Nqh+Erk`=>3K}u}Rg*;iuJe9rZU8FI{&RgDT{JoAu4P&w&Y(vA-N=h;E@Qv`t z*fM7wh+~aAd7I2DY2Mx!ueUM+5C}p3pZHOyi7S&5r<+6iB$useF4F7kgyb$Mlq4}Pf3t|Vv8kgPtRQi(Nm zd$;Wetvh`sqF>OwWYNwN!ZK7xQtAfA>a&7bY#jO34e8;IIN-IN^w4B$AW>Ns$cJp*1QtZ?Hl==|M zU)YsTq?I|)hVsQ8Rb(G)yONXz(8PgWOTWQKl#eh(TKKdaXQb6a$^*vLZ-eO=TdXWYyX~L-@t(?lh}8n5lgYj(vp-2 z+V578(M&(ZZC~Vj_osC@v%-c&AfXw?fFlP6YzpzJ^Ks;Ja;-5*&LIV$(;A5=_gbB|V3(LRv16;!xZ+m?`tjerp)*hFgF!QumP%8!YoC+@O zAH{g4UDGQg-T8I}@}Ko&?UNr%ozu3Rj|YzyK3!Sf#&O=zW*fX)Wj7?y1!{ zk)fC$STt0yO?T5h-s=Yn9j~2yJOuSP{XHNt_$y72DHu4cDWHjr{PWED_B(8wvWd&jOFTVg^Y>rBi(t2j>3butF*M2Afn`i32+!HE3S>-a z2rQ?JEp}I)&qJ)E8>))Nmcp@w9u0meBztlA?lD~52~Xz=y=xVjK&BPmb5w4S;*!*8 zbI$f%IB_dWqDubsu!(xo4S2po-yhE_oh--UZ~QRg-Xe;`=ucE_iXNpT4=sK7<~j55 zvr7oP4s7BZI6ULhN8IU~)8IQcS293I%U~7{BCF2n}C#Sy0mo-oVTD{E~g^;>HrAkWT{YMf{YzWf&fH9H`$Z9EQ%0aTxi$`-F#0iwn z<8Ogf^gpX4vKf|<^5<}C-(>Lxw@FMXsEJ=A8%C?H#8KOx@xUwSK;+`&xU3pYQ| zT#H06oMwovYpQ-`@;pedJA(1_);9mJEfJ7@qRtExB6sP1u9M>OX>eK3Z+3jfcQIcq zWLly2pbBp$I{>N@u$!MvEi-Ha0hZs|E<_?RI1UfD@H&#cJf^Q)0-JENvvcBg6zj$- zAg^Z`eQXiwsQ(m32@AKr5qIY)=z7>eUP#|z9931A7umY%#N4AISIJ94#~U{O7iRm^ z+u@AV&`G_+nS*biY}KTkUD}4Du2{2}We{CTgJNU~61!wh#)s8mRj|?kOc2pvR)2^9|^54=z?G= z;W~9XuXY2%ut!z5kbcG;T&$Cdyaz#7>B|1)pR)@W40kKKzmkJ#NQbyYVa;R493|f^ zc1Br)uEAt8=e<2P*J?{NE{-X^yoLGIbG1;Io(6`T-O3bsmic@OYFv;n`JP}$WkI@5sa zX*?HAwLjeGpr3%ySBBZl=^WLipgU&3cV=IyuY{~SsiZKTdVd5G$-MHm!AswaGrWzW z&b?ttuSe=Ac<1!u5o%g>>GBxI&5Q2hfe*#2bJVXw*mQKx$g=sJJ>no(TnN!LVlrvj zHFfFxL7c!N-+~(rAsb8yB!*D`y*_k-D@G+lf|C28Pww zzYAU)zy``UVohw2HaV|19aZrflV!+%-AuTrxR0^2JQAr$(V897TSrP)SWtF7A{+wj zX5md8^zV#X2}?Nu#lD@i)jWLrfg=}gt!g3{jY2cmS(x_4MWoU_iT!XL(QJtmCZieb z+S1l~-7$CwS_1kN3C@HMl(JMY&4g*XK$Q*X8aEvPihn$!^}!<52T`(2m{ zN%%97{-HxHyr4pUH;)IhS9O!IqcHba&sb^q4qEk&?)hFQydSh*!_AF+zg@v{y485t z#lvTMDD-vc!(xE?Lx-onbtCw@Jzbn`W8wSQH{0qv zrcqWF8J_veb~2}G9SKv|7=j6sB)o7VgLtb`+q@3BI8R3AdZ8m3T=X9mHVoK~`MTxW z+;&%$=MnL5#maU`A68KF-_S<=T2%`hMeddoaq^{@j7?dY=%!y_6MhD%Nw5zoAUeQ; z3htEkDQ6paV}J;Rm&f?S`s{epzr&HvL(M;v^X-KC(;)4mD~cUyCp|&y%^g+M=6)2# zkDwNrn<+qhp?l^!bvA&iV*OA|kq}q{h5W;auky(~UET~2<7y(Vc`dmH5U*ZVCwYtP z7T$Hxk9(Cf893NMCQQPf95PxsVQmiaJ@pkFK&kz@YKB-f3-Fp3ak$00+%AX6`2^>- z9QIG~!k<4jWCHowW$RoF><@N}#mTOPo@NmMJfj=VrkGAZ_zD>pNbG{~(;8uCu@^QB zd$-LdcEv+r4E~S3P;w)wLIaBv;)ZS{*qrYy0R;T)IF@&#i>@*t!Xm#O$G5+B30+i2 zR}Z^Yd(|d{V`x8OqWsMDOkxlY$nSUWVDBDs6QTbhL_>a4p1V(SU?j;>QjUng29Wpj z^6e3|5{mvVG^no?ytc@}ZA#8TO*w17SvlR7kFZ#hqtS^ON;%)?9XvU3w@AR#PL#SFj(;B4+asWJNFmz*RKRWH{-C)F1PZ`=z(`^?*}n3PIy6MK!ZxcPWtMC zmNaeh64Jj}{2uZ$%&=H87HY(ZT##|I%&@`mX~pyc{qn97YUwYhO{@f%YW^>-Fz5LIOodh1_Xs@;zTz~k^&ssH<**nZ(bHtFEKchWv- znE}zbLW?qY}z2EO*Ff~!uMRE7gR_AM?dry0KA5>5Meg33ig4OcfK~VZ+R`Co@ z;{4y|Ljc{txWKLd9*XN`{YnQsQfp2*T|Ei1uV7g{;plkH-7EdIU=ee(UxC-9>J>F za3Abp|9XGFT2tOW?8S4P3d6O@s+VtL({bCQ%^>TD=ZAb9yNn^$RPQBKlOW2SVrgMhDl6geY)f9^T|)G z!vchTY=26F*K(V&1^_Qm-+0*cN9pC(wp#5`tB3dYj7H7kId;Abpb~QX@_O`^IUeMr zJL=NfBkuL(=(ohEnmt%>`nN+O>*3_4pXp#jZ;hm9d_IG|`*;5TJ9@{%=P4`ecAQN@ zAGzDR1{nbVo&0~IXLTM;Ub%2|pQLwAsns?AYqcm@IUDR z_}Wrnlds{_XjU`dAOw|(r~w4{|6h?8HEJRtA-82FTLj~h{C1!2my)a)?i!NG7S|*F z;>H|&%eu@MnOdWQI9s$kzGwfpY44N61?}8%uf)(tykeuEWVjQXjd_V@JMo`iXrVrw zq^~czl?M4H%I+)a=1!%K>RT+m)xJ_k4Z{c|cZ6>}U<%&)q=_~<&{)ne2S0%0tsszaw~sLP7UTcSDBL}y zH?3x6z&Tu!6FI)~_k8uAa{n&<&vHsWFB9_cEdTzu^nd<~DNm=-`kB79$j%wOj^HbPX5g0HY0^i#K%KPiz z)$hbVG5F8E*gxrkf9Sw>MS$=00FFRo5-MWX=W746zhgtwvliP%VLxIb$t1wBCjk9^ zti5D3;A7ef#svq>2_*k3;qD4}HNpOZ{w>>cC^a@3U}w<6;7rTR0?SYyJCpk{+3-@SL~cvcu{Mb4_iYuADDtbg?apl6izeoA#d5``p9j9wUc4k$qogsd z4hxkZHJGtf5QuN5*(FQx@+Z6`Pfm2?TlNNEn|WBwY=FO%>-B-Z*&;WR}T1qx{oN!C1NZ*G2Q4I<~a%a0?%y0A-X5 zIg2w9kxFr?9C7wE>tZOy)Iu^3(l6NW7$oo4GxXc;R9TG`Sqd8UGkO_rTuYy|J$(}F z8C#roL296xw#IwphKg}te>e|;V4TE-#ukl5=r{8DgLQl=D;V`r1v_wjZi9%_K90+# ze?hL(;;1!~Ok%jBNotUT^>lMO7s?;~qFH{3&Hq*M1q}CQ{8DJF)U=aL%s)UBr~6X) z0yYXo>kHwXx~eZ2GCppAURqi}Q8wLh7c!AcK>DW{6Ymg7wWxT>i?cQyh}mn3d=XIA zzQe50p_bT&)|=jMqXl59Au0j&cahK^Rjn%EG8swU;Zxc6WR=b<+@Z>=Tj?rpnBjqJ z>~^cAMi(S3b~-&W@;o?ofMIW>LlY-h{td7QO4MGp-Ukb%(dL`XQFB*p@y9mp|&) zAMLBmw8{pq*d=!X$UFjVj$pVn73JanUbN(r{YkEx_6S;YNg3hq^EC%_c*k6&*srRqb>u^uU@jtYx z*}f>kk&$vWH5KV|FlFcf6W*}%xk{3$54PHI7j2C(1%>&Flwc;?Q*p8b>~46zW={a$ z%<4fsRh9#5b1CBH_IOx-V{FUq3odrw-{VMNMPVP#=GeiTz)mZgqjAe-WmDeh*S4>} zgnGPMj97kF;r8LPiXyx}ud^~Zvb6^I1kk4##-*ocRf3yepl^;kWmsp6GMuWEfPB<) zdpz4?&DSm=$urw|!aslm(2WJ;pzCXuSzO0(i6nPOE3XR1i3%dcrccH6h6ena)?!G= zAM`RJT7mJ%0h`9z&w}r%T+|xYjCn~8kV`Wv>UrYAhowBbQjVAD`}>^s5bbW*IogPA ze=FFX85=}q4B(EC&xo=@IXKA*eh<`O~4K}{$) z-|aV-En~{NXdB^@qd>UIC16h#WIuJxto9sm2KExgjYei+!FHn>#r8du4yvg->R=(v zE1?_W9m=UUY9P$md@X1Pvb1Xq;P)f@7dyM^`eLZ>iB8<_hl=bztQ?+Ykhr#4hDdFA zg@3X2IPrqp++`hB@{k}lPt&76a2P)NZ2SA*$@;H5@MOLWu@7Y?pBQT7VW_^0?<-)h z5`_hs?>5MHC4BfI@*?a9;`D9w!?&tncMLZ6ld8<%exs2ON3Jvc-2|tVJFr@jj>C2t6|~P*v7wv+)agsKUw5S@m6CM|fGHsbk9nn^Z5PtMN`|0I*-Axi&}CQ58snyPXkz=qcU z?Plxut?^{!*i8Cihx~dSZW5T?A}FWW?4;!e$qenP!jnqU`LM4X(P`fHF});|dUe4o z@5(mX35F&jNuE9Sg_}65eXDr_Dyb$PiZ=sSrWPbH>)=}#h(u+qK+ib~*3v?qvYDmFZH8g+19hmNMa5j=#uZs~w}_H5lH)YOqIWO?Pt%~i zV!FzEv5i72TcepgHj;zz0%KzV7;#vyc$xzD6-%eA=pKP}_dC zX{F@X?Bh^+<#wFr^8%MJIg>|1(zo=$V^vcVWwQVs(=;7dJL*j!+(EJp+p@KV{p%nlq#y4j&78 zV*7_$svhWdV4OM}a%G4!xU`KPJA*#L)C3OMd*Pd4pl{po5f^K51x)nBrqFdpR$JN0 zgWc6b0q%XS(X*8yxs(`D-*Gr$~9c z_jRbbJIB<09!;~K7sK>r8g zIfb|2U9E5pPZ+VR5lKQO(^8T3=<>`Kz6zb^9Hd{XK>z=L?dNY8YMtrK*Y#NWl1da& zPDaY-vhZfI{74)f$*M;~2Q>bb&73b>qMDCjokg2Jceb5G=X~PSIkfJd1jkril~iH_ zNe_@HK*`OAPs!wC)WZWm*wy$7x)R4aPD}Si2aCQfJd-8pv0la#zYE?rh3mI>$Zzc+ z^%6q3rR{p1kI*7P`b-F=ZR;Xqi}sY}MeT?f+{`Tjk8}VtCFSwt zazIQZhYqt{(t9tC^!oNblenwBK5CeT_He9xJ%|NwPq40Y%mUuJOxUNYIc|I6 zd^XRhlgc_L&FWSiq7~UVPirSybG?|hGK_}@tx@uZz`)ifLJxHwmzq^fnWp=s0UGju zTAv4L_m)-K=b*G@+M~+xRN)&~{N{S5eMJ*Jn`JsYkI$M3HebJ6W=`isE=JpmrHHXt#g$qM*A; z^-0tH&gD5tleo zJMO;2B-*83&%=D$&cB|FDf$3;NFFH+ak%}O1X-M_oz=#{ z8iOh8PpE}xOyqbm;0m6BNZ~q8R1>uOfL^EpCkm=pR&JISY$suu@|)Gn6-3WypUk6% z1F~oqs3W1GXrmSeW^O#*z< z#P1#lGK-yJh;>p?!_aJ8sd)`hTHRw7FPJ}i!9ZU|TLy{UtFb$fQWs&qKZJ5g){y89>6x- z^@%w}VV4wYyQ;{r@{-=WUP(3Mb(DHHyyt%N@Rfs~caadI{IP%@m9=2^4K~^+3sLd5}S0mQU4fv=u^N?)oAxBkjhV8srIR4gw<9bng{Y^3gKL{>=48F z)Xfs^Cc~LShcWKB`KQYa%hK(`2TTp#Ah@)kdK=`y^<+yeX$8@ayPrwxGM zh~FK{`1pl|KkM7l@`|)DJrU~m&v|_xRIqhxicOuCkET)6jcmz>)PFLvt|OwoRyi#N z$7A=F@Gn&t=aHBOyL*KYg!NWyB{Qpqt!@~h<;K!EHug}l?HUb?P$G+;1c=Quio>{8 zsF|ip=S4iX4=HQ{azD^eDAJ1}`e-%kqej+W`6zY|`>C+Tm+qE|v2y~L9a(LBV0~0i zkpa6MGGxwJYVAl8*12ab zz>m{}jSaRILD;--u&2__8a8AiEvu9aCNV1ZE@7w-9|&@cb}XHCIpN1WlD;@!=q(;J zy1FxXTnAwX5W5B$kV{vuhVxa-AqQXj6W3J6Y!y*zN>BB;h;X2jiFUFN@zW~(10WYbY$DBY`Nb7Lfc|%R0O1e*Gd~~)?B4`s3XW#xvy-OXElkMj z7)F3;NkDJ7$57pBQ|7jBLN(=TPJVkoq?`lLH7^K$A4jdseZYDD>l7=Ks!(Fs{1@+~ zRfdz%r7t54B(M%+2&E18E-n+Qi_%zPK2 zAS+m`WTNZr0KcYezy!D7fx3-}fZEe>5?;wz8+v26Vph~!CWTD!$rs3Hn;n<#K4;%d z_Q%hF_c&fHwd7Zn_NK@IZg>%d?s&jTsf-2-rngI5L z8xbctM*$zReD0nr=mo$Zo%&__Q_D{ZNCPN)Y}ZM#^4u?}L&H`uWb zKNPoW|Jk62D(QyuPlmpnYigrJol3VgBIa*5ypM)Cx-$@PP%i;Vq)n;i`k~)KaCCNp zVk56G^(--E%zpd|)Wb9iy=b=oT$d|=k#ikSClAt+)5gkQb-++{=ezl`;wy-=cl9@2 ziH?uZl<_rj^cef=uX+R(qc2I&M+inRMhd~pLu*P9wer&+VZi0mIeWugYstuGe8fy? z?wLR$RP6|RXpVV2+cYh0zPaoDYg_)e&1hQpRg<9!CD4yEiTR`pHuy*FJ@HRpV6!6 z>3qz3M^-Aa)ufT{6>R!{2ki~J$N$)SAeN+n9uH=4$SG~x=l5owJ=s~>sl{_^-@5?g@X*Pjx77d6W`tRb90`$BS{b)-o^pQ_!4yPiui5#>>8wYS$?oy}8C2S;- zVG+Q@hcIgNmtt)9(ANiTpCsD28UKKaLB5Tzb{PPPJcDp8xjs#!Kn2m z_5)BGcMdL}wk!?HaZiYX;6oFN_oqBz&hAoF{>cjqIu=*ify23IMz_K>z;~r^snxF%1itKVWxt<7K~T0SM^zD28HeP9m=5 zpj`Y_1RDZ*>Ee8n6#LN>Gib%)CGH6^VzS5H*`TH=@6z&&+h`CknpPrfhDQ6~XGrrL9=Ntzg~uMZS(u!8fhJ+)&aL*34;wEw5S}+m zN0eeM?2hl7qu0c^Y9g-aT3vUYU2{bT(j;oeriIk5*elBu&9BOy)s9^fW>}!eEajoV zB<1Q_fC(22i~-0v;wr)MnanAjSQ08BCYyu)dbrW7Uapao?z3tgOZ>hpD>hFcgnZ~- zv#rHY`EIUg|MMlCh@G@*fexMX-8bh%^3hQ7qxj=pId8{6J=*;gu8*@Q9ALjN1hT0B z`GuCK+G4G|IXe6u3Oo;kzvCl2rCtf-rley(^P;THF@S2Ss&j&6M>sf|mA$Yua`eLN zP;(J=^fcao$rrki6fim_CSdOCdu(3`9Am+_diQHP)2 z(JD1ugulwuwL*A@mjU|%_e-{%$On5b777m0)zh%{SGFwQ(M@4MiC_ZVg-Xq%EZrKl zkOT8OqDd6`_zIZl7P^~2=6utV$&hM{s)uSBfOf_PS-u$>5>zKSAlfk3?ty+WnP=-Z zA*coT4<#r@+D7-XnlVVoA@h_Py0zu8L0Ucn2U~h8SzI5)jGN@b<(l5TK^ye&-iYTp z3}h_eSi5vs0(u`QhYTbFd8NFQ7v8T5qa*QLx6>KsX9ZhYVcNSImtDv@&mgN~&*1g= zzb?DCSq4J1zi*TXo*KpAsp|<>C%*Z4OSX}0g@6e3d&3zN~nt3WBDD_oRGTmuNm0r?%r23ZHDhe?6< zw2j-!mZCMcyq9TfoSlEq8A?Qb}uy;G=#MkIM7mYa#I=|FpX&?V1yP zQ(IDmZ{kkasLKAIcDn_3eh=bu%{J5Lg&Voby$0+b%H+DO%Wiido&ZCHg`|)2=^20XQnI9#vyq)mQww2>U{F#E6|8=DJ-FQ!>{?niD=KfTEI>;X{ z#p@0y2zYeyvLa~hFElTn6(Vpcy6biQin(#JBgcd6mt4NiYi>tah@I!!{CkmkjTEH#kLpq4Jx9|zVyFY(8N<8A|~a;!Xg zU4ta_!{=s8x=8h>sB+N`f|gLV~i%eE*24+or zKmGy{;-gJ`9cTR~Lf=AigTrb6Guz*3z#d?p^3QsKIv{1Ml{-cJcl9I5IO@Hby`D?) z;aD|q>8R?T^#ss;qW5IP5(njw4$vcD2+J8+*Zm#OzY&R$i1kiL!$OJU{;^2OE~SG< zYx};~@~~dw&7drv(?W#FDi~JLMMk1wLs6v@4(C1CWc*~*wOE=pB?XW`3b41KRY1o z75TZBC#exv!Ut!uDynyM?ZhTBQG2k*)BoJ|y@2I$y}jmH4yH}>-iuR+mtdKD7htx} zmd$PyHKAkDu3dow6_!o$KEtb&c$Iw^wRNlN#yn7N{&!f-)|6t_@uLET4*H;urTX*&R-Gf53GE&o6 z-w;gtbhsU|^~J|Ep-&FJYo@K9bo8RJvxZ+MDbr(93SW(X!DEst*{WDDpkvT$zEITe zcz|MklQ6_IC0}%rQLfq=U&jgzipQp8DnB8fu@3lF$rYU_o`=%(P+h(QhWIrM1v;%z z{T#IjSr_DVUar?Uo;g&P)*_qm;3uyIEBm&JbGs&DHT z-hgyBDkV}PNQZ25@_`JXO z{LVf1x$phlXa2FjYm7POm}8FFbFH=4rldQGBUykh)4_sQ-bzr|Z2!@q!MDP9h|g*wDW`9&X7epmWVJLT_O>78+`87}xV6VG{^NPScl(!eXX-g+1bLe$ z(<+?MnKB}3vEO0k-Qg_@<_G%s<5D?qsiXYR;LZh8}T4tYn>>lenQX!1GL znU>TH@UgZm={~%7Ik7H(xYP+L=@oY*kw+>5^9GoA!m-&m(080~{5elBqU5sQXLGc@ zL@YPGZt~5)uUyCB153dpFkgWAseue!2QZ)gIe+~* zKmDH1kn( zWZqSG6GX*uHW>S>o*C&JPhVBpbz*R z*dtTAlC4Aqy{6-?#Pg)-dhWUsg~#HOh1T-PMdGCG{s5|bV(^auREg7F(>$r;tYR$d zbrcJ2kboWyp{K705_JE`2lj$|K)xCx-^BN7X9WTMXFTxNzsvtK{Xe6DJ>VQ~d28nz z*t&U-q4nBGla>5`QFAx9nX%W2JVLCZv1Y5;Yp){9S(KoB=uHKy6n zYy18ieabk0Pw>9j^Tr68SCh67jw8YJ#9rq-H{&<;#i(hdjcsg`?{2pGllSJ($}$~D z7CnEV+ucw0Nn@?LR(W>1-%h%j@{L08r5cPk&8k+^rTwUzQy4ce`eQqPO5AX~Gd?;g z8y%0K_|aX(dxEcue`bo(M4g;yw6jEGOJaDwC|j0XOW8d2=xFPk?y{U&x(BcGP=wMqYtC5DrsL66y0GCjo9prN_q#) z>zH+33^)AC%O-nxUc0T>?XA!pnjd>?I-i1b`#=4beAOMw>cS=r>;?J$Y0t{FmnHt} zSS5dz?~|4*2dMftYu`lM6t9^K(1HQ7aOZYy`uw9TBXUQID>tT$HN2WUS-zo#bUhct zsZ>zju#KxdKqJ#S0Q^cPlCPgk4_s03Wm^yF?zpzLx(M(%M^pXmegPFcUeBx_eo)0( zaO(@i^u*w0Y^Ve%SA?F1##4gG>@K6~Se}=L&c8zN%VjK1J1F7=%$A^&8>pG;o$dQG$k%xkER@j4=c?Od`Y^W$AUHy!!PoHt!!0&VO z46`C^dQl?)%Jtn&fKrQ?4G{zwZIsh=8&06=~m6ALKL;|DICeSe5s>LSkhom}uhzc3aRJiqi;ARSoO%Y9b&wK?IPxkyQAWk>Q$ zBzPALY}1pL@ce zt!^o1JLHIOG6jWH}`f7SXajR|rF|Z4KZws7r@07`0C_BoU6G48L3LwKJ z$4EPE?ceKgzPFMU`2p{2K>h$hy|IZ)&&z6#yaoAy@2HMMfBeL;^)0Z&c6)1keHYmp zA&?Ao3}W^gqcK4r+$*ihjKLZ#tz`-8uvZ`*Pt=z~{(Vv$XBhbu_l$a_s07iE!jf@gX11|$yNS%C?!p))@6X- z(}L7U6HJ#srOaoDgJI@jfQl^4R9$^@C+8PPJlU^q``+0}?s<4DkbH!kjifRC>< zajTs=^HH)@MCX@H|5Uf7tmZ0I4R8<|wTb7$Qy?fJL-(aSeU2&T(uw+m=2&{>Lm(De6!QMA!HRiQZ|~ZZN*WveQsaZB zQSr6KOnF5%`W3nE5UAzQtsJg}VD-^k6AecGr#g6w!n&R2!X&tpUt^BMa&eb$s(eOy zE91WZA*7StMd@pL*PAju1|p{jMeYGp`rDq4&~@pOV_rdw-EP~|fh;o*ONr``?qtnY zPR}U4xDXuL<@lCTx$NKxm7Z)YG3rF`LN#obimVIc`^-0B0l9^%2K_yy1m3zR7493o zZ+0tRGurt0zy67xCmnA4Jt+EVRyfYP(iCeq(-338t&ouwS5dxxJz% ze)nGQmelRV#RIu+-fqW!8vPz_;2_3&IYyDt?k3C#?Uxy$ZDB@8p|rtYNd_ zS5|C%A9#w;06v+#^4ReKt{(0LMqH3d)Ga5J_pBYCmU34(%EPsZ!x@Bw*p9b9*70|D zp~`sZN~6WU9*5BH@Qr8?h2ar@^9o)5=>0PJ z3AY4^%UHUqY>rcxviN%pu6<8%;kOAPdCW&2*x~Z3NsZGJpY@r{t4c9ZiUPdK$0B=f zay^lYp7Pd~azz3!BSmK}_&o?5{9&p=jQMInmY=RCmD0C^OON|;&;D+e!rfK-`#G=f zcq|vZAa<~bkjOXgjCd&#B&N6WrD^`!+Db9f0cAK!8zvU3iGwb6&M=1k!^q2 zgwp^`tcek{4KL#b9)1j(#*Ieck4u&OOa$o#6ZKP{`*ttEn)K139@9^?UL0~T(REN4 zhNkQEbQNd9Y=!-u9wgFgtA5TSyXf<*koVzWU7I;Q1iYpTDdEk|xa9CD4(J8>ge-fO zf5B@@1$?#+wZz~W7jOG~dHt2_Dq_ca^B zU{z(e<8)|)cxaD}^4l1xqnNy&RG(DM(l}z>(VubPk6B}-7C*we_r(#an;HCTI2PpN z^7i>hmXEPu8VBtEG6WSGtry%t8-q&&Nt?z#x z$>{sICG)|z5>DFVtIiggB=zY&g15hSSrNEaOVI^G%>0DX;2&;qVdi`iibJ~d!~Fu8 zj7v8T^;$d?9)3Un=Ox3prC93TiT2)?o3EpknI)L12Hqd|$mgCwOsdedJc`?7H0cmu zRV`I|Yw5V-{)=ORcVh2yMrI$mdGE?yy#n;TbW66F92Xr2>zzFJ5bG-;*6YMcX6PA~ zd}I52gqJL_K7O`)wb4vm=Fdm2$vl?bJmvB!LH%v~fd23M{G7H6cLP{ltt8axJaKIE zUGSIQ%=pxXjmQ=(;8dV`I>G@&d-z7e_Z0rnryzNAYJ zCq@>}SXcWfq+s{%jg(Kkd{6lcT0ga9qod4z-2Q&_@ zz0U)~VxPYAlHHuta&Kr|`AZ*s>AQQ3@qM9KAt6RL_)wrC>Q0Ko-m1(F*~RQlcQ>`Y zE?Etmat_N4s-o|;T|zInaR9a?(FtV{T$gVox^e^H)b zZ)OlOn{{&F=S7WiON83N*~{=gz13L7QRIf7@~~ZLg>6$Xea=$!<&0p7d!@X2TGv~Z z^oD9e$St8CL>6u=*h*GPKTNnp-qAny?0&5SZS0-w-}g5&nH=?AJKYmC7L^FjV=qtT z$<8l{qwas?)ZqF?WfXIIqA>;POO0Pbfb20pOw+4Ievvw53b8|EMFUj-XP-L&>qLN{ zLpCzl5#chDjq%jGYsFC;;DG;W8QTA*mwRV_{tk)#Z5I2%C+Xo{nspB%699trYav0N zq^kyxu^Sf^qrxao!1I~gDfIfUo2r!9HB!WjhEDdoymR#vzHrr{x`fk5A12py|G4q! z%4F9Az}F6V$6(ulHO5*=RORrtmJvg%u+%b_B@x8`GgQ}zdlQnm_d%4rv9Ep2#)Nu>S0TeQhWAS^($&xC&R{%!EQ=(p-q%4XZH1o1A zpV>J7e-Q}8na$SQoVf)mb@C~Qf~hb!Ht?;E^uR#0Z}PyXGQ%UkEh2^1V*P1zd3Q%W zaTm>ub_n5JSqUy8miICfWzvbX7vSG*E;_(A1PkXH>dsX(e~;HezrL1;VdN1eqih6A z5qAmo_1@e|@@}`dm`60MwTB;q=1EccD&;kQSWS=Oy6AA;V6u886Q;&zRs=&2;_|_e zS{dJ((aH#y9R50K*tsjZ@OWTXDm6)P;mGY$zB%wyH$Ez&{ zJ4HvE_mdlSd{=rqK6AV%rr76`y~;?0Y(V^Ggh56bGHDQkYbEi|0tQOdt&X14P&SdN zptFS%`{Dq8mOb4-0VQ_G8%i(3wH3aliK|lg%tJ!zKs$UhfFg|M?0AGNj9JYy-ySnS zu>T;|X0)EXAFvg_5_Wlxq zC$;!|VRz23nZfS+P-lMDa&x?o3-0aH@^0a%j^61*foS-7R&~NZFL!VX_lf7t3mdIUCiOvP>5-E)$Z-_)KGZ-CMb^xp}H`OQC)RIsaRB2V-(@$F^Cwm3yX2|`L$}Wc_Gf;@$=5lmJzG!5Wa55 z=FGvp`JO2UNPY;-sLTE3>(39@hswW-NUz3}z8}M0DQC!ipPM6WlLZ#L%O7! z42O-O6F2UBHe&R~Sn9!Zx)cA4^dgJ~=hIhuC4Omd@`=z{_mNk{l<2X7yLi*=s%dq> z2Lr*VLJ8>1q?qM9!QTghE9!VB(&f3mwF9$*j5TRmGN0foB@HmS$HN4SsT`FbVMG?M zFi<&frbf)mi-ZEcv18clgoVo&P6DWvdR8+0C2tBA_c-s6 z%+Ge5GM0L4k?K3Rr&9CJR^Y!&klMF8R?CxU;F`aRY=}5wz7x`y0$Kz1J37d#K1PG~ z$!cwShf!s!4bY5SQ?IX$xnM5X28BepYs^$WjeB9vQp-S(Tg8G`P=#q$O33AXyY;a` zv8cTHl>FAswPbP4=os3F;XHkVt3n&fD=zKI3LL(=m$Ys?3oH@9zB?*!V`fPL|KRYh*W1ynEhRP%P*`-%H=>AlCIV%K=( zL*CMmr